From 456c817338e3ce899e524eff603f47c583de24aa Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 27 Feb 2020 09:18:54 -0500 Subject: Decompile fldeff hooks --- src/field_effect.c | 243 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 243 insertions(+) create mode 100644 src/field_effect.c (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c new file mode 100644 index 000000000..c9c388966 --- /dev/null +++ b/src/field_effect.c @@ -0,0 +1,243 @@ +#include "global.h" +#include "gflib.h" +#include "field_effect.h" +#include "field_effect_scripts.h" +#include "field_weather.h" +#include "overworld.h" +#include "quest_log.h" + +#define FIELD_EFFECT_COUNT 32 + +static u8 sFieldEffectActiveList[FIELD_EFFECT_COUNT]; + +void FieldEffectActiveListAdd(u8 fldeff); +void FieldEffectScript_LoadTiles(const u8 **script); +void FieldEffectScript_LoadFadedPal(const u8 **script); +void FieldEffectScript_LoadPal(const u8 **script); +void FieldEffectScript_CallNative(const u8 **script, u32 *result); +void FieldEffectFreeTilesIfUnused(u16 tilesTag); +void FieldEffectFreePaletteIfUnused(u8 paletteNum); + +extern bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result); + +u32 FieldEffectStart(u8 fldeff) +{ + const u8 *script; + u32 result; + FieldEffectActiveListAdd(fldeff); + script = gFieldEffectScriptPointers[fldeff]; + while (sFldEffScrcmdTable[*script](&script, &result)) + ; + return result; +} + +bool8 FieldEffectCmd_loadtiles(const u8 **script, u32 *result) +{ + (*script)++; + FieldEffectScript_LoadTiles(script); + return TRUE; +} + +bool8 FieldEffectCmd_loadfadedpal(const u8 **script, u32 *result) +{ + (*script)++; + FieldEffectScript_LoadFadedPal(script); + return TRUE; +} + +bool8 FieldEffectCmd_loadpal(const u8 **script, u32 *result) +{ + (*script)++; + FieldEffectScript_LoadPal(script); + return TRUE; +} +bool8 FieldEffectCmd_callnative(const u8 **script, u32 *result) +{ + (*script)++; + FieldEffectScript_CallNative(script, result); + return TRUE; +} + +bool8 FieldEffectCmd_end(const u8 **script, u32 *result) +{ + return FALSE; +} + +bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result) +{ + (*script)++; + FieldEffectScript_LoadTiles(script); + FieldEffectScript_LoadFadedPal(script); + FieldEffectScript_CallNative(script, result); + return TRUE; +} + +bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result) +{ + (*script)++; + FieldEffectScript_LoadTiles(script); + FieldEffectScript_CallNative(script, result); + return TRUE; +} + +bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result) +{ + (*script)++; + FieldEffectScript_LoadFadedPal(script); + FieldEffectScript_CallNative(script, result); + return TRUE; +} + +u32 FieldEffectScript_ReadWord(const u8 **script) +{ + return T2_READ_32(*script); +} + +void FieldEffectScript_LoadTiles(const u8 **script) +{ + const struct SpriteSheet * spriteSheet = (const struct SpriteSheet *)FieldEffectScript_ReadWord(script); + if (GetSpriteTileStartByTag(spriteSheet->tag) == 0xFFFF) + LoadSpriteSheet(spriteSheet); + *script += sizeof(u32); +} + +void sub_8083598(u8 paletteIdx) +{ + switch (gUnknown_2036E28) + { + case 0: + return; + case 1: + TintPalette_GrayScale(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], 0x10); + break; + case 2: + TintPalette_SepiaTone(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], 0x10); + break; + case 3: + sub_8111F38((paletteIdx + 16) * 16, 0x10); + TintPalette_GrayScale(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], 0x10); + break; + default: + return; + } + CpuFastCopy(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], &gPlttBufferFaded[(paletteIdx + 16) * 16], 0x20); +} + +void FieldEffectScript_LoadFadedPal(const u8 **script) +{ + const struct SpritePalette * spritePalette = (const struct SpritePalette *)FieldEffectScript_ReadWord(script); + u8 idx = IndexOfSpritePaletteTag(spritePalette->tag); + LoadSpritePalette(spritePalette); + if (idx == 0xFF) + sub_8083598(IndexOfSpritePaletteTag(spritePalette->tag)); + sub_807AA8C(IndexOfSpritePaletteTag(spritePalette->tag)); + *script += sizeof(u32); +} + +void FieldEffectScript_LoadPal(const u8 **script) +{ + const struct SpritePalette * spritePalette = (const struct SpritePalette *)FieldEffectScript_ReadWord(script); + u8 idx = IndexOfSpritePaletteTag(spritePalette->tag); + LoadSpritePalette(spritePalette); + if (idx != 0xFF) + sub_8083598(IndexOfSpritePaletteTag(spritePalette->tag)); + *script += sizeof(u32); +} + +void FieldEffectScript_CallNative(const u8 **script, u32 *result) +{ + u32 (*func)(void) = (u32 (*)(void))FieldEffectScript_ReadWord(script); + *result = func(); + *script += sizeof(u32); +} + +void FieldEffectFreeGraphicsResources(struct Sprite * sprite) +{ + u16 tileStart = sprite->sheetTileStart; + u8 paletteNum = sprite->oam.paletteNum; + DestroySprite(sprite); + FieldEffectFreeTilesIfUnused(tileStart); + FieldEffectFreePaletteIfUnused(paletteNum); +} + +void FieldEffectStop(struct Sprite * sprite, u8 fldeff) +{ + FieldEffectFreeGraphicsResources(sprite); + FieldEffectActiveListRemove(fldeff); +} + +void FieldEffectFreeTilesIfUnused(u16 tileStart) +{ + u8 i; + u16 tileTag = GetSpriteTileTagByTileStart(tileStart); + if (tileTag == 0xFFFF) + return; + for (i = 0; i < MAX_SPRITES; i++) + { + if (gSprites[i].inUse && gSprites[i].usingSheet && tileStart == gSprites[i].sheetTileStart) + return; + } + FreeSpriteTilesByTag(tileTag); +} + +void FieldEffectFreePaletteIfUnused(u8 paletteNum) +{ + u8 i; + u16 paletteTag = GetSpritePaletteTagByPaletteNum(paletteNum); + if (paletteTag == 0xFFFF) + return; + for (i = 0; i < MAX_SPRITES; i++) + { + if (gSprites[i].inUse && gSprites[i].oam.paletteNum == paletteNum) + return; + } + FreeSpritePaletteByTag(paletteTag); +} + +void FieldEffectActiveListClear(void) +{ + u8 i; + for (i = 0; i < FIELD_EFFECT_COUNT; i++) + { + sFieldEffectActiveList[i] = 0xFF; + } +} + +void FieldEffectActiveListAdd(u8 fldeff) +{ + u8 i; + for (i = 0; i < FIELD_EFFECT_COUNT; i++) + { + if (sFieldEffectActiveList[i] == 0xFF) + { + sFieldEffectActiveList[i] = fldeff; + return; + } + } +} + +void FieldEffectActiveListRemove(u8 fldeff) +{ + u8 i; + for (i = 0; i < FIELD_EFFECT_COUNT; i++) + { + if (sFieldEffectActiveList[i] == fldeff) + { + sFieldEffectActiveList[i] = 0xFF; + return; + } + } +} + +bool8 FieldEffectActiveListContains(u8 fldeff) +{ + u8 i; + for (i = 0; i < FIELD_EFFECT_COUNT; i++) + { + if (sFieldEffectActiveList[i] == fldeff) + { + return TRUE; + } + } + return FALSE; +} -- cgit v1.2.3 From 0d88e2d1de7135d7cc3d724398fa8d9022831511 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 27 Feb 2020 14:08:26 -0500 Subject: through MultiplyPaletteRGBComponents --- src/field_effect.c | 212 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 211 insertions(+), 1 deletion(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index c9c388966..35a56389a 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -1,16 +1,27 @@ #include "global.h" #include "gflib.h" +#include "data.h" +#include "decompress.h" #include "field_effect.h" #include "field_effect_scripts.h" #include "field_weather.h" #include "overworld.h" #include "quest_log.h" +#include "trainer_pokemon_sprites.h" #define FIELD_EFFECT_COUNT 32 static u8 sFieldEffectActiveList[FIELD_EFFECT_COUNT]; void FieldEffectActiveListAdd(u8 fldeff); +bool8 FieldEffectCmd_loadtiles(const u8 **script, u32 *result); +bool8 FieldEffectCmd_loadfadedpal(const u8 **script, u32 *result); +bool8 FieldEffectCmd_loadpal(const u8 **script, u32 *result); +bool8 FieldEffectCmd_callnative(const u8 **script, u32 *result); +bool8 FieldEffectCmd_end(const u8 **script, u32 *result); +bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result); +bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result); +bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result); void FieldEffectScript_LoadTiles(const u8 **script); void FieldEffectScript_LoadFadedPal(const u8 **script); void FieldEffectScript_LoadPal(const u8 **script); @@ -18,7 +29,106 @@ void FieldEffectScript_CallNative(const u8 **script, u32 *result); void FieldEffectFreeTilesIfUnused(u16 tilesTag); void FieldEffectFreePaletteIfUnused(u8 paletteNum); -extern bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result); +const u16 sNewGameOakObjectSpriteTiles[] = INCBIN_U16("graphics/field_effects/unk_83CA770.4bpp"); +const u16 sNewGameOakObjectPals[] = INCBIN_U16("graphics/field_effects/unk_83CAF70.gbapal"); +const u16 gUnknown_83CAF90[] = INCBIN_U16("graphics/field_effects/unk_83CAF90.4bpp"); +const u16 gUnknown_83CAFB0[] = INCBIN_U16("graphics/field_effects/unk_83CAFB0.gbapal"); +const u16 gUnknown_83CAFD0[] = INCBIN_U16("graphics/field_effects/unk_83CAFD0.4bpp"); +const u16 gUnknown_83CB3D0[] = INCBIN_U16("graphics/field_effects/unk_83CB3D0.gbapal"); +const u16 gUnknown_83CB3F0[] = INCBIN_U16("graphics/field_effects/unk_83CB3F0.4bpp"); +const u16 gUnknown_83CB5F0[] = INCBIN_U16("graphics/field_effects/unk_83CB5F0.4bpp"); +const u16 gUnknown_83CB7F0[] = INCBIN_U16("graphics/field_effects/unk_83CB7F0.gbapal"); +const u16 gUnknown_83CB810[] = INCBIN_U16("graphics/field_effects/unk_83CB810.bin"); +const u16 gUnknown_83CBA90[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp"); +const u16 gUnknown_83CBB10[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal"); +const u16 gUnknown_83CBB30[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin"); +const u16 gUnknown_83CBDB0[] = INCBIN_U16("graphics/field_effects/unk_83CBDB0.4bpp"); + +bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = { + FieldEffectCmd_loadtiles, + FieldEffectCmd_loadfadedpal, + FieldEffectCmd_loadpal, + FieldEffectCmd_callnative, + FieldEffectCmd_end, + FieldEffectCmd_loadgfx_callnative, + FieldEffectCmd_loadtiles_callnative, + FieldEffectCmd_loadfadedpal_callnative +}; + +const struct OamData gNewGameOakOamAttributes = { + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .mosaic = FALSE, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(64x64), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(64x64), + .tileNum = 0x000, + .priority = 0, + .paletteNum = 0x0, + .affineParam = 0 +}; + +const struct OamData gOamData_83CBE58 = { + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .mosaic = FALSE, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(8x8), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(8x8), + .tileNum = 0x000, + .priority = 0, + .paletteNum = 0x0, + .affineParam = 0 +}; + +const struct OamData gOamData_83CBE60 = { + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .mosaic = FALSE, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(16x16), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(16x16), + .tileNum = 0x000, + .priority = 0, + .paletteNum = 0x0, + .affineParam = 0 +}; + +const struct SpriteFrameImage gNewGameOakObjectSpriteFrames[] = { + {sNewGameOakObjectSpriteTiles, 0x800} +}; + +const struct SpritePalette gNewGameOakObjectPaletteInfo = { + sNewGameOakObjectPals, 4102 +}; + +const union AnimCmd gNewGameOakAnim[] = { + ANIMCMD_FRAME(0, 1), + ANIMCMD_END +}; + +const union AnimCmd *const gNewGameOakAnimTable[] = { + gNewGameOakAnim +}; + +const struct SpriteTemplate gNewGameOakObjectTemplate = { + .tileTag = 0xFFFF, + .paletteTag = 4102, + .oam = &gNewGameOakOamAttributes, + .anims = gNewGameOakAnimTable, + .images = gNewGameOakObjectSpriteFrames, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy +}; u32 FieldEffectStart(u8 fldeff) { @@ -241,3 +351,103 @@ bool8 FieldEffectActiveListContains(u8 fldeff) } return FALSE; } + +u8 CreateTrainerSprite(u8 trainerSpriteID, s16 x, s16 y, u8 subpriority, u8 *buffer) +{ + struct SpriteTemplate spriteTemplate; + LoadCompressedSpritePaletteOverrideBuffer(&gTrainerFrontPicPaletteTable[trainerSpriteID], buffer); + LoadCompressedSpriteSheetOverrideBuffer(&gTrainerFrontPicTable[trainerSpriteID], buffer); + spriteTemplate.tileTag = gTrainerFrontPicTable[trainerSpriteID].tag; + spriteTemplate.paletteTag = gTrainerFrontPicPaletteTable[trainerSpriteID].tag; + spriteTemplate.oam = &gNewGameOakOamAttributes; + spriteTemplate.anims = gDummySpriteAnimTable; + spriteTemplate.images = NULL; + spriteTemplate.affineAnims = gDummySpriteAffineAnimTable; + spriteTemplate.callback = SpriteCallbackDummy; + return CreateSprite(&spriteTemplate, x, y, subpriority); +} + +void LoadTrainerGfx_TrainerCard(u8 gender, u16 palOffset, u8 *dest) +{ + LZDecompressVram(gTrainerFrontPicTable[gender].data, dest); + LoadCompressedPalette(gTrainerFrontPicPaletteTable[gender].data, palOffset, 0x20); +} + +u8 AddNewGameBirchObject(s16 x, s16 y, u8 subpriority) +{ + LoadSpritePalette(&gNewGameOakObjectPaletteInfo); + return CreateSprite(&gNewGameOakObjectTemplate, x, y, subpriority); +} + +u8 CreateMonSprite_PicBox(u16 species, s16 x, s16 y, u8 subpriority) +{ + u16 spriteId = CreateMonPicSprite_HandleDeoxys(species, 0, 0x8000, TRUE, x, y, 0, gMonPaletteTable[species].tag); + PreservePaletteInWeather(IndexOfSpritePaletteTag(gMonPaletteTable[species].tag) + 0x10); + if (spriteId == 0xFFFF) + return MAX_SPRITES; + else + return spriteId; +} + +u8 CreateMonSprite_FieldMove(u16 species, u32 d, u32 g, s16 x, s16 y, u8 subpriority) +{ + const struct CompressedSpritePalette *spritePalette = GetMonSpritePalStructFromOtIdPersonality(species, d, g); + u16 spriteId = CreateMonPicSprite_HandleDeoxys(species, d, g, 1, x, y, 0, spritePalette->tag); + PreservePaletteInWeather(IndexOfSpritePaletteTag(spritePalette->tag) + 0x10); + if (spriteId == 0xFFFF) + return MAX_SPRITES; + else + return spriteId; +} + +void FreeResourcesAndDestroySprite(struct Sprite *sprite, u8 spriteId) +{ + ResetPreservedPalettesInWeather(); + if (sprite->oam.affineMode != ST_OAM_AFFINE_OFF) + { + FreeOamMatrix(sprite->oam.matrixNum); + } + FreeAndDestroyMonPicSprite(spriteId); +} + +// r, g, b are between 0 and 16 +void MultiplyInvertedPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b) +{ + int curRed; + int curGreen; + int curBlue; + u16 outPal; + + outPal = gPlttBufferUnfaded[i]; + curRed = outPal & 0x1f; + curGreen = (outPal & (0x1f << 5)) >> 5; + curBlue = (outPal & (0x1f << 10)) >> 10; + curRed += (((0x1f - curRed) * r) >> 4); + curGreen += (((0x1f - curGreen) * g) >> 4); + curBlue += (((0x1f - curBlue) * b) >> 4); + outPal = curRed; + outPal |= curGreen << 5; + outPal |= curBlue << 10; + gPlttBufferFaded[i] = outPal; +} + +// r, g, b are between 0 and 16 +void MultiplyPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b) +{ + int curRed; + int curGreen; + int curBlue; + u16 outPal; + + outPal = gPlttBufferUnfaded[i]; + curRed = outPal & 0x1f; + curGreen = (outPal & (0x1f << 5)) >> 5; + curBlue = (outPal & (0x1f << 10)) >> 10; + curRed -= ((curRed * r) >> 4); + curGreen -= ((curGreen * g) >> 4); + curBlue -= ((curBlue * b) >> 4); + outPal = curRed; + outPal |= curGreen << 5; + outPal |= curBlue << 10; + gPlttBufferFaded[i] = outPal; +} -- cgit v1.2.3 From 701d4635b4880fd9055e0b0f3e5032b5d0353ab1 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 27 Feb 2020 16:19:33 -0500 Subject: Pokecenter heal and HOF field effects --- src/field_effect.c | 531 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 531 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 35a56389a..b7498d316 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -7,8 +7,11 @@ #include "field_weather.h" #include "overworld.h" #include "quest_log.h" +#include "task.h" #include "trainer_pokemon_sprites.h" +#include "constants/songs.h" +#define subsprite_table(ptr) {.subsprites = ptr, .subspriteCount = (sizeof ptr) / (sizeof(struct Subsprite))} #define FIELD_EFFECT_COUNT 32 static u8 sFieldEffectActiveList[FIELD_EFFECT_COUNT]; @@ -28,6 +31,10 @@ void FieldEffectScript_LoadPal(const u8 **script); void FieldEffectScript_CallNative(const u8 **script, u32 *result); void FieldEffectFreeTilesIfUnused(u16 tilesTag); void FieldEffectFreePaletteIfUnused(u8 paletteNum); +void Task_PokecenterHeal(u8 taskId); +void SpriteCB_PokeballGlow(struct Sprite * sprite); +void SpriteCB_PokecenterMonitor(struct Sprite * sprite); +void SpriteCB_HallOfFameMonitor(struct Sprite * sprite); const u16 sNewGameOakObjectSpriteTiles[] = INCBIN_U16("graphics/field_effects/unk_83CA770.4bpp"); const u16 sNewGameOakObjectPals[] = INCBIN_U16("graphics/field_effects/unk_83CAF70.gbapal"); @@ -130,6 +137,187 @@ const struct SpriteTemplate gNewGameOakObjectTemplate = { .callback = SpriteCallbackDummy }; +const struct SpritePalette gUnknown_83CBE9C = { + gUnknown_83CAFB0, 4103 +}; + +const struct SpritePalette gUnknown_83CBEA4 = { + gUnknown_83CB3D0, 4112 +}; + +const struct OamData gOamData_83CBEAC = { + .y = 0, + .affineMode = ST_OAM_AFFINE_OFF, + .objMode = ST_OAM_OBJ_NORMAL, + .mosaic = FALSE, + .bpp = ST_OAM_4BPP, + .shape = SPRITE_SHAPE(32x16), + .x = 0, + .matrixNum = 0, + .size = SPRITE_SIZE(32x16), + .tileNum = 0x000, + .priority = 0, + .paletteNum = 0x0, + .affineParam = 0 +}; + +const struct SpriteFrameImage gUnknown_83CBEB4[] = { + {gUnknown_83CAF90, 0x20} +}; + +const struct SpriteFrameImage gUnknown_83CBEBC[] = { + {gUnknown_83CAFD0 + 0x000, 0x100}, + {gUnknown_83CAFD0 + 0x080, 0x100}, + {gUnknown_83CAFD0 + 0x100, 0x100}, + {gUnknown_83CAFD0 + 0x180, 0x100} +}; + +const struct SpriteFrameImage gUnknown_83CBEDC[] = { + {gUnknown_83CB3F0 + 0x00, 0x80}, + {gUnknown_83CB3F0 + 0x40, 0x80}, + {gUnknown_83CB3F0 + 0x80, 0x80}, + {gUnknown_83CB3F0 + 0xC0, 0x80} +}; + +const struct Subsprite gUnknown_83CBEFC[] = +{ + { + .x = -12, + .y = -8, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 0, + .priority = 2 + }, { + .x = 4, + .y = -8, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 2, + .priority = 2 + }, { + .x = -12, + .y = 0, + .shape = SPRITE_SHAPE(16x8), + .size = SPRITE_SIZE(16x8), + .tileOffset = 3, + .priority = 2 + }, { + .x = 4, + .y = 0, + .shape = SPRITE_SHAPE(8x8), + .size = SPRITE_SIZE(8x8), + .tileOffset = 5, + .priority = 2 + } +}; + +const struct SubspriteTable gUnknown_83CBF0C = subsprite_table(gUnknown_83CBEFC); + +const struct Subsprite gUnknown_83CBF14[] = +{ + { + .x = -32, + .y = -8, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 0, + .priority = 2 + }, { + .x = 0, + .y = -8, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 4, + .priority = 2 + }, { + .x = -32, + .y = 0, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 8, + .priority = 2 + }, { + .x = 0, + .y = 0, + .shape = SPRITE_SHAPE(32x8), + .size = SPRITE_SIZE(32x8), + .tileOffset = 12, + .priority = 2 + } +}; + +const struct SubspriteTable gUnknown_83CBF24 = subsprite_table(gUnknown_83CBF14); + +const union AnimCmd gUnknown_83CBF2C[] = { + ANIMCMD_FRAME(0, 1), + ANIMCMD_JUMP(0) +}; + +const union AnimCmd gUnknown_83CBF34[] = { + ANIMCMD_FRAME(1, 5), + ANIMCMD_FRAME(2, 5), + ANIMCMD_FRAME(3, 7), + ANIMCMD_FRAME(2, 5), + ANIMCMD_FRAME(1, 5), + ANIMCMD_FRAME(0, 5), + ANIMCMD_LOOP(3), + ANIMCMD_END +}; + +const union AnimCmd *const gUnknown_83CBF54[] = { + gUnknown_83CBF2C, + gUnknown_83CBF34 +}; + +const union AnimCmd gUnknown_83CBF5C[] = { + ANIMCMD_FRAME(3, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(0, 8), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(2, 8), + ANIMCMD_LOOP(2), + ANIMCMD_FRAME(1, 8), + ANIMCMD_FRAME(0, 8), + ANIMCMD_END +}; + +const union AnimCmd *const gUnknown_83CBF84[] = { + gUnknown_83CBF5C +}; + +const struct SpriteTemplate gUnknown_83CBF88 = { + .tileTag = 65535, + .paletteTag = 4103, + .oam = &gOamData_83CBE58, + .anims = gUnknown_83CBF54, + .images = gUnknown_83CBEB4, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCB_PokeballGlow +}; + +const struct SpriteTemplate gUnknown_83CBFA0 = { + .tileTag = 65535, + .paletteTag = 4103, + .oam = &gOamData_83CBEAC, + .anims = gUnknown_83CBF54, + .images = gUnknown_83CBEBC, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCB_PokecenterMonitor +}; + +const struct SpriteTemplate gUnknown_83CBFB8 = { + .tileTag = 65535, + .paletteTag = 4112, + .oam = &gOamData_83CBE60, + .anims = gUnknown_83CBF84, + .images = gUnknown_83CBEDC, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCB_HallOfFameMonitor +}; + + u32 FieldEffectStart(u8 fldeff) { const u8 *script; @@ -451,3 +639,346 @@ void MultiplyPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b) outPal |= curBlue << 10; gPlttBufferFaded[i] = outPal; } + +void PokecenterHealEffect_0(struct Task * task); +void PokecenterHealEffect_1(struct Task * task); +void PokecenterHealEffect_2(struct Task * task); +void PokecenterHealEffect_3(struct Task * task); +void HallOfFameRecordEffect_0(struct Task * task); +void HallOfFameRecordEffect_1(struct Task * task); +void HallOfFameRecordEffect_2(struct Task * task); +void HallOfFameRecordEffect_3(struct Task * task); +void Task_HallOfFameRecord(u8 taskId); +u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare); +void SpriteCB_PokeballGlowEffect(struct Sprite * sprite); +void PokeballGlowEffect_0(struct Sprite * sprite); +void PokeballGlowEffect_1(struct Sprite * sprite); +void PokeballGlowEffect_2(struct Sprite * sprite); +void PokeballGlowEffect_3(struct Sprite * sprite); +void PokeballGlowEffect_4(struct Sprite * sprite); +void PokeballGlowEffect_5(struct Sprite * sprite); +void PokeballGlowEffect_6(struct Sprite * sprite); +void PokeballGlowEffect_7(struct Sprite * sprite); +u8 PokecenterHealEffectHelper(s32 x, s32 y); +void HallOfFameRecordEffectHelper(s32 x, s32 y); + +void (*const sPokecenterHealTaskCBTable[])(struct Task *) = { + PokecenterHealEffect_0, + PokecenterHealEffect_1, + PokecenterHealEffect_2, + PokecenterHealEffect_3 +}; + +void (*const sHallOfFameRecordTaskCBTable[])(struct Task *) = { + HallOfFameRecordEffect_0, + HallOfFameRecordEffect_1, + HallOfFameRecordEffect_2, + HallOfFameRecordEffect_3 +}; + +void (*const sPokeballGlowSpriteCBTable[])(struct Sprite *) = { + PokeballGlowEffect_0, + PokeballGlowEffect_1, + PokeballGlowEffect_2, + PokeballGlowEffect_3, + PokeballGlowEffect_4, + PokeballGlowEffect_5, + PokeballGlowEffect_6, + PokeballGlowEffect_7 +}; + +bool8 FldEff_PokecenterHeal(void) +{ + u8 nPokemon; + struct Task *task; + + nPokemon = CalculatePlayerPartyCount(); + task = &gTasks[CreateTask(Task_PokecenterHeal, 0xff)]; + task->data[1] = nPokemon; + task->data[2] = 0x5d; + task->data[3] = 0x24; + task->data[4] = 0x80; + task->data[5] = 0x18; + return FALSE; +} + +void Task_PokecenterHeal(u8 taskId) +{ + struct Task * task = &gTasks[taskId]; + sPokecenterHealTaskCBTable[task->data[0]](task); +} + +void PokecenterHealEffect_0(struct Task *task) +{ + task->data[0]++; + task->data[6] = CreatePokeballGlowSprite(task->data[1], task->data[2], task->data[3], TRUE); + task->data[7] = PokecenterHealEffectHelper(task->data[4], task->data[5]); +} + +void PokecenterHealEffect_1(struct Task *task) +{ + if (gSprites[task->data[6]].data[0] > 1) + { + gSprites[task->data[7]].data[0]++; + task->data[0]++; + } +} + +void PokecenterHealEffect_2(struct Task *task) +{ + if (gSprites[task->data[6]].data[0] > 4) + { + task->data[0]++; + } +} + +void PokecenterHealEffect_3(struct Task *task) +{ + if (gSprites[task->data[6]].data[0] > 6) + { + DestroySprite(&gSprites[task->data[6]]); + FieldEffectActiveListRemove(FLDEFF_POKECENTER_HEAL); + DestroyTask(FindTaskIdByFunc(Task_PokecenterHeal)); + } +} + + +bool8 FldEff_HallOfFameRecord(void) +{ + u8 nPokemon; + struct Task *task; + + nPokemon = CalculatePlayerPartyCount(); + task = &gTasks[CreateTask(Task_HallOfFameRecord, 0xff)]; + task->data[1] = nPokemon; + task->data[2] = 0x75; + task->data[3] = 0x3C; + return FALSE; +} + +void Task_HallOfFameRecord(u8 taskId) +{ + struct Task *task; + task = &gTasks[taskId]; + sHallOfFameRecordTaskCBTable[task->data[0]](task); +} + +void HallOfFameRecordEffect_0(struct Task *task) +{ + u8 taskId; + task->data[0]++; + task->data[6] = CreatePokeballGlowSprite(task->data[1], task->data[2], task->data[3], FALSE); +} + +void HallOfFameRecordEffect_1(struct Task *task) +{ + if (gSprites[task->data[6]].data[0] > 1) + { + HallOfFameRecordEffectHelper(0x78, 0x19); + task->data[15]++; // was this ever initialized? is this ever used? + task->data[0]++; + } +} + +void HallOfFameRecordEffect_2(struct Task *task) +{ + if (gSprites[task->data[6]].data[0] > 4) + { + task->data[0]++; + } +} + +void HallOfFameRecordEffect_3(struct Task *task) +{ + if (gSprites[task->data[6]].data[0] > 6) + { + DestroySprite(&gSprites[task->data[6]]); + FieldEffectActiveListRemove(FLDEFF_HALL_OF_FAME_RECORD); + DestroyTask(FindTaskIdByFunc(Task_HallOfFameRecord)); + } +} + +u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare) +{ + u8 spriteId; + struct Sprite *sprite; + spriteId = CreateInvisibleSprite(SpriteCB_PokeballGlowEffect); + sprite = &gSprites[spriteId]; + sprite->pos2.x = x; + sprite->pos2.y = y; + sprite->subpriority = 0xFF; + sprite->data[5] = fanfare; + sprite->data[6] = duration; + sprite->data[7] = spriteId; + return spriteId; +} + +void SpriteCB_PokeballGlowEffect(struct Sprite * sprite) +{ + sPokeballGlowSpriteCBTable[sprite->data[0]](sprite); +} + +const struct Coords16 gUnknown_83CC010[] = { + {0, 0}, + {6, 0}, + {0, 4}, + {6, 4}, + {0, 8}, + {6, 8} +}; + +const u8 gUnknown_83CC028[] = {16, 12, 8, 0}; +const u8 gUnknown_83CC02C[] = {16, 12, 8, 0}; +const u8 gUnknown_83CC030[] = { 0, 0, 0, 0}; + +void PokeballGlowEffect_0(struct Sprite *sprite) +{ + u8 endSpriteId; + if (sprite->data[1] == 0 || (--sprite->data[1]) == 0) + { + sprite->data[1] = 25; + endSpriteId = CreateSpriteAtEnd(&gUnknown_83CBF88, gUnknown_83CC010[sprite->data[2]].x + sprite->pos2.x, gUnknown_83CC010[sprite->data[2]].y + sprite->pos2.y, 0xFF); + gSprites[endSpriteId].oam.priority = 2; + gSprites[endSpriteId].data[0] = sprite->data[7]; + sprite->data[2]++; + sprite->data[6]--; + PlaySE(SE_BOWA); + } + if (sprite->data[6] == 0) + { + sprite->data[1] = 32; + sprite->data[0]++; + } +} + +void PokeballGlowEffect_1(struct Sprite *sprite) +{ + if ((--sprite->data[1]) == 0) + { + sprite->data[0]++; + sprite->data[1] = 8; + sprite->data[2] = 0; + sprite->data[3] = 0; + if (sprite->data[5]) + { + PlayFanfare(MUS_ME_ASA); + } + } +} + +void PokeballGlowEffect_2(struct Sprite *sprite) +{ + u8 phase; + if ((--sprite->data[1]) == 0) + { + sprite->data[1] = 8; + sprite->data[2]++; + sprite->data[2] &= 3; + if (sprite->data[2] == 0) + { + sprite->data[3]++; + } + } + phase = (sprite->data[2] + 3) & 3; + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x108, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + phase = (sprite->data[2] + 2) & 3; + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x106, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + phase = (sprite->data[2] + 1) & 3; + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x102, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + phase = sprite->data[2]; + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x105, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + if (sprite->data[3] > 2) + { + sprite->data[0]++; + sprite->data[1] = 8; + sprite->data[2] = 0; + } +} + +void PokeballGlowEffect_3(struct Sprite *sprite) +{ + u8 phase; + if ((--sprite->data[1]) == 0) + { + sprite->data[1] = 8; + sprite->data[2]++; + sprite->data[2] &= 3; + if (sprite->data[2] == 3) + { + sprite->data[0]++; + sprite->data[1] = 30; + } + } + phase = sprite->data[2]; + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x108, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x106, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x102, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x105, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); +} + +void PokeballGlowEffect_4(struct Sprite *sprite) +{ + if ((--sprite->data[1]) == 0) + { + sprite->data[0]++; + } +} + +void PokeballGlowEffect_5(struct Sprite *sprite) +{ + sprite->data[0]++; +} + +void PokeballGlowEffect_6(struct Sprite *sprite) +{ + if (sprite->data[5] == 0 || IsFanfareTaskInactive()) + { + sprite->data[0]++; + } +} + +void PokeballGlowEffect_7(struct Sprite *sprite) +{ +} + +void SpriteCB_PokeballGlow(struct Sprite * sprite) +{ + if (gSprites[sprite->data[0]].data[0] > 4) + FieldEffectFreeGraphicsResources(sprite); +} + +u8 PokecenterHealEffectHelper(s32 x, s32 y) +{ + u8 spriteId; + struct Sprite * sprite; + spriteId = CreateSpriteAtEnd(&gUnknown_83CBFA0, x, y, 0); + sprite = &gSprites[spriteId]; + sprite->oam.priority = 2; + sprite->invisible = TRUE; + return spriteId; +} + +void SpriteCB_PokecenterMonitor(struct Sprite * sprite) +{ + if (sprite->data[0] != 0) + { + sprite->data[0] = 0; + sprite->invisible = FALSE; + StartSpriteAnim(sprite, 1); + } + if (sprite->animEnded) + FieldEffectFreeGraphicsResources(sprite); +} + +void HallOfFameRecordEffectHelper(s32 x, s32 y) +{ + CreateSpriteAtEnd(&gUnknown_83CBFB8, x, y, 0); +} + +void SpriteCB_HallOfFameMonitor(struct Sprite * sprite) +{ + if (sprite->animEnded) + FieldEffectFreeGraphicsResources(sprite); +} -- cgit v1.2.3 From 9c03c850a2bfbedc3ccadf8b0f1a895607c113ae Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 27 Feb 2020 16:35:06 -0500 Subject: Fly field effect --- src/field_effect.c | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index b7498d316..9a30088c1 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -2,11 +2,15 @@ #include "gflib.h" #include "data.h" #include "decompress.h" +#include "event_object_movement.h" #include "field_effect.h" #include "field_effect_scripts.h" +#include "field_fadetransition.h" #include "field_weather.h" #include "overworld.h" +#include "party_menu.h" #include "quest_log.h" +#include "script.h" #include "task.h" #include "trainer_pokemon_sprites.h" #include "constants/songs.h" @@ -982,3 +986,83 @@ void SpriteCB_HallOfFameMonitor(struct Sprite * sprite) if (sprite->animEnded) FieldEffectFreeGraphicsResources(sprite); } + +void FieldCallback_Fly(void); +void Task_FlyOut(u8 taskId); +void FieldCallback_FlyArrive(void); +void Task_FlyIn(u8 taskId); + +void ReturnToFieldFromFlyMapSelect(void) +{ + SetMainCallback2(CB2_ReturnToField); + gFieldCallback = FieldCallback_Fly; +} + +void FieldCallback_Fly(void) +{ + FadeInFromBlack(); + CreateTask(Task_FlyOut, 0); + ScriptContext2_Enable(); + FreezeObjectEvents(); + gFieldCallback = NULL; +} + +void Task_FlyOut(u8 taskId) +{ + struct Task * task; + task = &gTasks[taskId]; + if (task->data[0] == 0) + { + if (!IsWeatherNotFadingIn()) + return; + gFieldEffectArguments[0] = GetCursorSelectionMonId(); + if ((int)gFieldEffectArguments[0] >= PARTY_SIZE) + gFieldEffectArguments[0] = 0; + FieldEffectStart(FLDEFF_USE_FLY); + task->data[0]++; + } + if (!FieldEffectActiveListContains(FLDEFF_USE_FLY)) + { + Overworld_ResetStateAfterFly(); + WarpIntoMap(); + SetMainCallback2(CB2_LoadMap); + gFieldCallback = FieldCallback_FlyArrive; + DestroyTask(taskId); + } +} + +void FieldCallback_FlyArrive(void) +{ + Overworld_PlaySpecialMapMusic(); + FadeInFromBlack(); + CreateTask(Task_FlyIn, 0); + gObjectEvents[gPlayerAvatar.objectEventId].invisible = TRUE; + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING) + { + ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], DIR_WEST); + } + ScriptContext2_Enable(); + FreezeObjectEvents(); + gFieldCallback = NULL; +} + +void Task_FlyIn(u8 taskId) +{ + struct Task *task; + task = &gTasks[taskId]; + if (task->data[0] == 0) + { + if (gPaletteFade.active) + { + return; + } + FieldEffectStart(FLDEFF_FLY_IN); + task->data[0]++; + } + if (!FieldEffectActiveListContains(FLDEFF_FLY_IN)) + { + ScriptContext2_Disable(); + UnfreezeObjectEvents(); + DestroyTask(taskId); + } +} -- cgit v1.2.3 From e07c771f1840fe614ac1040d55ce842602f44c4c Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Thu, 27 Feb 2020 16:59:05 -0500 Subject: through Task_FallWarpFieldEffect --- src/field_effect.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 9a30088c1..f85a9aef5 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -1066,3 +1066,40 @@ void Task_FlyIn(u8 taskId) DestroyTask(taskId); } } + +void Task_FallWarpFieldEffect(u8 taskId); +bool8 FallWarpEffect_1(struct Task * task); +bool8 FallWarpEffect_2(struct Task * task); +bool8 FallWarpEffect_3(struct Task * task); +bool8 FallWarpEffect_4(struct Task * task); +bool8 FallWarpEffect_5(struct Task * task); +bool8 FallWarpEffect_6(struct Task * task); +bool8 FallWarpEffect_7(struct Task * task); + +bool8 (*const sFallWarpEffectCBPtrs[])(struct Task * task) = { + FallWarpEffect_1, + FallWarpEffect_2, + FallWarpEffect_3, + FallWarpEffect_4, + FallWarpEffect_5, + FallWarpEffect_6, + FallWarpEffect_7 +}; + +void FieldCB_FallWarpExit(void) +{ + Overworld_PlaySpecialMapMusic(); + pal_fill_for_maplights(); + sub_8111CF0(); + ScriptContext2_Enable(); + FreezeObjectEvents(); + CreateTask(Task_FallWarpFieldEffect, 0); + gFieldCallback = NULL; +} + +void Task_FallWarpFieldEffect(u8 taskId) +{ + struct Task * task = &gTasks[taskId]; + while (sFallWarpEffectCBPtrs[task->data[0]](task)) + ; +} -- cgit v1.2.3 From db12644f0001346604c19e4004eead5cd2203fea Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 09:06:19 -0500 Subject: FallWarpEffect funcs --- src/field_effect.c | 126 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 126 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index f85a9aef5..a8102c1d9 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -2,11 +2,16 @@ #include "gflib.h" #include "data.h" #include "decompress.h" +#include "event_data.h" #include "event_object_movement.h" +#include "field_camera.h" #include "field_effect.h" #include "field_effect_scripts.h" #include "field_fadetransition.h" +#include "field_player_avatar.h" #include "field_weather.h" +#include "fieldmap.h" +#include "help_system.h" #include "overworld.h" #include "party_menu.h" #include "quest_log.h" @@ -1103,3 +1108,124 @@ void Task_FallWarpFieldEffect(u8 taskId) while (sFallWarpEffectCBPtrs[task->data[0]](task)) ; } + +bool8 FallWarpEffect_1(struct Task *task) +{ + struct ObjectEvent *playerObject; + struct Sprite *playerSprite; + playerObject = &gObjectEvents[gPlayerAvatar.objectEventId]; + playerSprite = &gSprites[gPlayerAvatar.spriteId]; + CameraObjectReset2(); + gObjectEvents[gPlayerAvatar.objectEventId].invisible = TRUE; + gPlayerAvatar.preventStep = TRUE; + ObjectEventSetHeldMovement(playerObject, GetFaceDirectionMovementAction(GetPlayerFacingDirection())); + task->data[4] = playerSprite->subspriteMode; + playerObject->fixedPriority = 1; + playerSprite->oam.priority = 1; + playerSprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY; + task->data[0]++; + return TRUE; +} + +bool8 FallWarpEffect_2(struct Task *task) +{ + if (IsWeatherNotFadingIn()) + { + task->data[0]++; + } + return FALSE; +} + +bool8 FallWarpEffect_3(struct Task *task) +{ + struct Sprite *sprite; + s16 centerToCornerVecY; + sprite = &gSprites[gPlayerAvatar.spriteId]; + centerToCornerVecY = -(sprite->centerToCornerVecY << 1); + sprite->pos2.y = -(sprite->pos1.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY + centerToCornerVecY); + task->data[1] = 1; + task->data[2] = 0; + gObjectEvents[gPlayerAvatar.objectEventId].invisible = FALSE; + PlaySE(SE_RU_HYUU); + task->data[0]++; + return FALSE; +} + +bool8 FallWarpEffect_4(struct Task *task) +{ + struct ObjectEvent *objectEvent; + struct Sprite *sprite; + + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + sprite = &gSprites[gPlayerAvatar.spriteId]; + sprite->pos2.y += task->data[1]; + if (task->data[1] < 8) + { + task->data[2] += task->data[1]; + if (task->data[2] & 0xf) + { + task->data[1] <<= 1; + } + } + if (task->data[3] == 0 && sprite->pos2.y >= -16) + { + task->data[3]++; + objectEvent->fixedPriority = 0; + sprite->subspriteMode = task->data[4]; + objectEvent->triggerGroundEffectsOnMove = 1; + } + if (sprite->pos2.y >= 0) + { + PlaySE(SE_W070); + objectEvent->triggerGroundEffectsOnStop = 1; + objectEvent->landingJump = 1; + sprite->pos2.y = 0; + task->data[0]++; + } + return FALSE; +} + +bool8 FallWarpEffect_5(struct Task *task) +{ + task->data[0]++; + task->data[1] = 4; + task->data[2] = 0; + SetCameraPanningCallback(NULL); + return TRUE; +} + +bool8 FallWarpEffect_6(struct Task *task) +{ + SetCameraPanning(0, task->data[1]); + task->data[1] = -task->data[1]; + task->data[2]++; + if ((task->data[2] & 3) == 0) + { + task->data[1] >>= 1; + } + if (task->data[1] == 0) + { + task->data[0]++; + } + return FALSE; +} + +bool8 FallWarpEffect_7(struct Task *task) +{ + s16 x, y; + gPlayerAvatar.preventStep = FALSE; + ScriptContext2_Disable(); + CameraObjectReset1(); + UnfreezeObjectEvents(); + InstallCameraPanAheadCallback(); + PlayerGetDestCoords(&x, &y); + // Seafoam Islands + if (sub_8055B38(MapGridGetMetatileBehaviorAt(x, y)) == TRUE) + { + VarSet(VAR_TEMP_1, 1); + SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_SURFING); + HelpSystem_SetSomeVariable2(22); + } + DestroyTask(FindTaskIdByFunc(Task_FallWarpFieldEffect)); + return FALSE; +} -- cgit v1.2.3 From 1779aedbf0e321188ff239095a3e20f38cf22575 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 10:02:40 -0500 Subject: Escalator field effect --- src/field_effect.c | 381 +++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 340 insertions(+), 41 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index a8102c1d9..a35fbfe7f 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -16,8 +16,11 @@ #include "party_menu.h" #include "quest_log.h" #include "script.h" +#include "special_field_anim.h" #include "task.h" #include "trainer_pokemon_sprites.h" +#include "trig.h" +#include "constants/metatile_behaviors.h" #include "constants/songs.h" #define subsprite_table(ptr) {.subsprites = ptr, .subspriteCount = (sizeof ptr) / (sizeof(struct Subsprite))} @@ -402,7 +405,7 @@ u32 FieldEffectScript_ReadWord(const u8 **script) void FieldEffectScript_LoadTiles(const u8 **script) { - const struct SpriteSheet * spriteSheet = (const struct SpriteSheet *)FieldEffectScript_ReadWord(script); + const struct SpriteSheet * spriteSheet = (const struct SpriteSheet * )FieldEffectScript_ReadWord(script); if (GetSpriteTileStartByTag(spriteSheet->tag) == 0xFFFF) LoadSpriteSheet(spriteSheet); *script += sizeof(u32); @@ -432,7 +435,7 @@ void sub_8083598(u8 paletteIdx) void FieldEffectScript_LoadFadedPal(const u8 **script) { - const struct SpritePalette * spritePalette = (const struct SpritePalette *)FieldEffectScript_ReadWord(script); + const struct SpritePalette * spritePalette = (const struct SpritePalette * )FieldEffectScript_ReadWord(script); u8 idx = IndexOfSpritePaletteTag(spritePalette->tag); LoadSpritePalette(spritePalette); if (idx == 0xFF) @@ -443,7 +446,7 @@ void FieldEffectScript_LoadFadedPal(const u8 **script) void FieldEffectScript_LoadPal(const u8 **script) { - const struct SpritePalette * spritePalette = (const struct SpritePalette *)FieldEffectScript_ReadWord(script); + const struct SpritePalette * spritePalette = (const struct SpritePalette * )FieldEffectScript_ReadWord(script); u8 idx = IndexOfSpritePaletteTag(spritePalette->tag); LoadSpritePalette(spritePalette); if (idx != 0xFF) @@ -588,7 +591,7 @@ u8 CreateMonSprite_PicBox(u16 species, s16 x, s16 y, u8 subpriority) u8 CreateMonSprite_FieldMove(u16 species, u32 d, u32 g, s16 x, s16 y, u8 subpriority) { - const struct CompressedSpritePalette *spritePalette = GetMonSpritePalStructFromOtIdPersonality(species, d, g); + const struct CompressedSpritePalette * spritePalette = GetMonSpritePalStructFromOtIdPersonality(species, d, g); u16 spriteId = CreateMonPicSprite_HandleDeoxys(species, d, g, 1, x, y, 0, spritePalette->tag); PreservePaletteInWeather(IndexOfSpritePaletteTag(spritePalette->tag) + 0x10); if (spriteId == 0xFFFF) @@ -597,7 +600,7 @@ u8 CreateMonSprite_FieldMove(u16 species, u32 d, u32 g, s16 x, s16 y, u8 subprio return spriteId; } -void FreeResourcesAndDestroySprite(struct Sprite *sprite, u8 spriteId) +void FreeResourcesAndDestroySprite(struct Sprite * sprite, u8 spriteId) { ResetPreservedPalettesInWeather(); if (sprite->oam.affineMode != ST_OAM_AFFINE_OFF) @@ -671,21 +674,21 @@ void PokeballGlowEffect_7(struct Sprite * sprite); u8 PokecenterHealEffectHelper(s32 x, s32 y); void HallOfFameRecordEffectHelper(s32 x, s32 y); -void (*const sPokecenterHealTaskCBTable[])(struct Task *) = { +void (*const sPokecenterHealTaskCBTable[])(struct Task * ) = { PokecenterHealEffect_0, PokecenterHealEffect_1, PokecenterHealEffect_2, PokecenterHealEffect_3 }; -void (*const sHallOfFameRecordTaskCBTable[])(struct Task *) = { +void (*const sHallOfFameRecordTaskCBTable[])(struct Task * ) = { HallOfFameRecordEffect_0, HallOfFameRecordEffect_1, HallOfFameRecordEffect_2, HallOfFameRecordEffect_3 }; -void (*const sPokeballGlowSpriteCBTable[])(struct Sprite *) = { +void (*const sPokeballGlowSpriteCBTable[])(struct Sprite * ) = { PokeballGlowEffect_0, PokeballGlowEffect_1, PokeballGlowEffect_2, @@ -699,7 +702,7 @@ void (*const sPokeballGlowSpriteCBTable[])(struct Sprite *) = { bool8 FldEff_PokecenterHeal(void) { u8 nPokemon; - struct Task *task; + struct Task * task; nPokemon = CalculatePlayerPartyCount(); task = &gTasks[CreateTask(Task_PokecenterHeal, 0xff)]; @@ -717,14 +720,14 @@ void Task_PokecenterHeal(u8 taskId) sPokecenterHealTaskCBTable[task->data[0]](task); } -void PokecenterHealEffect_0(struct Task *task) +void PokecenterHealEffect_0(struct Task * task) { task->data[0]++; task->data[6] = CreatePokeballGlowSprite(task->data[1], task->data[2], task->data[3], TRUE); task->data[7] = PokecenterHealEffectHelper(task->data[4], task->data[5]); } -void PokecenterHealEffect_1(struct Task *task) +void PokecenterHealEffect_1(struct Task * task) { if (gSprites[task->data[6]].data[0] > 1) { @@ -733,7 +736,7 @@ void PokecenterHealEffect_1(struct Task *task) } } -void PokecenterHealEffect_2(struct Task *task) +void PokecenterHealEffect_2(struct Task * task) { if (gSprites[task->data[6]].data[0] > 4) { @@ -741,7 +744,7 @@ void PokecenterHealEffect_2(struct Task *task) } } -void PokecenterHealEffect_3(struct Task *task) +void PokecenterHealEffect_3(struct Task * task) { if (gSprites[task->data[6]].data[0] > 6) { @@ -755,7 +758,7 @@ void PokecenterHealEffect_3(struct Task *task) bool8 FldEff_HallOfFameRecord(void) { u8 nPokemon; - struct Task *task; + struct Task * task; nPokemon = CalculatePlayerPartyCount(); task = &gTasks[CreateTask(Task_HallOfFameRecord, 0xff)]; @@ -767,19 +770,19 @@ bool8 FldEff_HallOfFameRecord(void) void Task_HallOfFameRecord(u8 taskId) { - struct Task *task; + struct Task * task; task = &gTasks[taskId]; sHallOfFameRecordTaskCBTable[task->data[0]](task); } -void HallOfFameRecordEffect_0(struct Task *task) +void HallOfFameRecordEffect_0(struct Task * task) { u8 taskId; task->data[0]++; task->data[6] = CreatePokeballGlowSprite(task->data[1], task->data[2], task->data[3], FALSE); } -void HallOfFameRecordEffect_1(struct Task *task) +void HallOfFameRecordEffect_1(struct Task * task) { if (gSprites[task->data[6]].data[0] > 1) { @@ -789,7 +792,7 @@ void HallOfFameRecordEffect_1(struct Task *task) } } -void HallOfFameRecordEffect_2(struct Task *task) +void HallOfFameRecordEffect_2(struct Task * task) { if (gSprites[task->data[6]].data[0] > 4) { @@ -797,7 +800,7 @@ void HallOfFameRecordEffect_2(struct Task *task) } } -void HallOfFameRecordEffect_3(struct Task *task) +void HallOfFameRecordEffect_3(struct Task * task) { if (gSprites[task->data[6]].data[0] > 6) { @@ -810,7 +813,7 @@ void HallOfFameRecordEffect_3(struct Task *task) u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare) { u8 spriteId; - struct Sprite *sprite; + struct Sprite * sprite; spriteId = CreateInvisibleSprite(SpriteCB_PokeballGlowEffect); sprite = &gSprites[spriteId]; sprite->pos2.x = x; @@ -840,7 +843,7 @@ const u8 gUnknown_83CC028[] = {16, 12, 8, 0}; const u8 gUnknown_83CC02C[] = {16, 12, 8, 0}; const u8 gUnknown_83CC030[] = { 0, 0, 0, 0}; -void PokeballGlowEffect_0(struct Sprite *sprite) +void PokeballGlowEffect_0(struct Sprite * sprite) { u8 endSpriteId; if (sprite->data[1] == 0 || (--sprite->data[1]) == 0) @@ -860,7 +863,7 @@ void PokeballGlowEffect_0(struct Sprite *sprite) } } -void PokeballGlowEffect_1(struct Sprite *sprite) +void PokeballGlowEffect_1(struct Sprite * sprite) { if ((--sprite->data[1]) == 0) { @@ -875,7 +878,7 @@ void PokeballGlowEffect_1(struct Sprite *sprite) } } -void PokeballGlowEffect_2(struct Sprite *sprite) +void PokeballGlowEffect_2(struct Sprite * sprite) { u8 phase; if ((--sprite->data[1]) == 0) @@ -905,7 +908,7 @@ void PokeballGlowEffect_2(struct Sprite *sprite) } } -void PokeballGlowEffect_3(struct Sprite *sprite) +void PokeballGlowEffect_3(struct Sprite * sprite) { u8 phase; if ((--sprite->data[1]) == 0) @@ -927,7 +930,7 @@ void PokeballGlowEffect_3(struct Sprite *sprite) MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); } -void PokeballGlowEffect_4(struct Sprite *sprite) +void PokeballGlowEffect_4(struct Sprite * sprite) { if ((--sprite->data[1]) == 0) { @@ -935,12 +938,12 @@ void PokeballGlowEffect_4(struct Sprite *sprite) } } -void PokeballGlowEffect_5(struct Sprite *sprite) +void PokeballGlowEffect_5(struct Sprite * sprite) { sprite->data[0]++; } -void PokeballGlowEffect_6(struct Sprite *sprite) +void PokeballGlowEffect_6(struct Sprite * sprite) { if (sprite->data[5] == 0 || IsFanfareTaskInactive()) { @@ -948,7 +951,7 @@ void PokeballGlowEffect_6(struct Sprite *sprite) } } -void PokeballGlowEffect_7(struct Sprite *sprite) +void PokeballGlowEffect_7(struct Sprite * sprite) { } @@ -1053,7 +1056,7 @@ void FieldCallback_FlyArrive(void) void Task_FlyIn(u8 taskId) { - struct Task *task; + struct Task * task; task = &gTasks[taskId]; if (task->data[0] == 0) { @@ -1109,10 +1112,10 @@ void Task_FallWarpFieldEffect(u8 taskId) ; } -bool8 FallWarpEffect_1(struct Task *task) +bool8 FallWarpEffect_1(struct Task * task) { - struct ObjectEvent *playerObject; - struct Sprite *playerSprite; + struct ObjectEvent * playerObject; + struct Sprite * playerSprite; playerObject = &gObjectEvents[gPlayerAvatar.objectEventId]; playerSprite = &gSprites[gPlayerAvatar.spriteId]; CameraObjectReset2(); @@ -1127,7 +1130,7 @@ bool8 FallWarpEffect_1(struct Task *task) return TRUE; } -bool8 FallWarpEffect_2(struct Task *task) +bool8 FallWarpEffect_2(struct Task * task) { if (IsWeatherNotFadingIn()) { @@ -1136,9 +1139,9 @@ bool8 FallWarpEffect_2(struct Task *task) return FALSE; } -bool8 FallWarpEffect_3(struct Task *task) +bool8 FallWarpEffect_3(struct Task * task) { - struct Sprite *sprite; + struct Sprite * sprite; s16 centerToCornerVecY; sprite = &gSprites[gPlayerAvatar.spriteId]; centerToCornerVecY = -(sprite->centerToCornerVecY << 1); @@ -1151,10 +1154,10 @@ bool8 FallWarpEffect_3(struct Task *task) return FALSE; } -bool8 FallWarpEffect_4(struct Task *task) +bool8 FallWarpEffect_4(struct Task * task) { - struct ObjectEvent *objectEvent; - struct Sprite *sprite; + struct ObjectEvent * objectEvent; + struct Sprite * sprite; objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; sprite = &gSprites[gPlayerAvatar.spriteId]; @@ -1185,7 +1188,7 @@ bool8 FallWarpEffect_4(struct Task *task) return FALSE; } -bool8 FallWarpEffect_5(struct Task *task) +bool8 FallWarpEffect_5(struct Task * task) { task->data[0]++; task->data[1] = 4; @@ -1194,7 +1197,7 @@ bool8 FallWarpEffect_5(struct Task *task) return TRUE; } -bool8 FallWarpEffect_6(struct Task *task) +bool8 FallWarpEffect_6(struct Task * task) { SetCameraPanning(0, task->data[1]); task->data[1] = -task->data[1]; @@ -1210,7 +1213,7 @@ bool8 FallWarpEffect_6(struct Task *task) return FALSE; } -bool8 FallWarpEffect_7(struct Task *task) +bool8 FallWarpEffect_7(struct Task * task) { s16 x, y; gPlayerAvatar.preventStep = FALSE; @@ -1229,3 +1232,299 @@ bool8 FallWarpEffect_7(struct Task *task) DestroyTask(FindTaskIdByFunc(Task_FallWarpFieldEffect)); return FALSE; } + +void Task_EscalatorWarpFieldEffect(u8 taskId); +bool8 EscalatorWarpEffect_1(struct Task * task); +bool8 EscalatorWarpEffect_2(struct Task * task); +bool8 EscalatorWarpEffect_3(struct Task * task); +bool8 EscalatorWarpEffect_4(struct Task * task); +bool8 EscalatorWarpEffect_5(struct Task * task); +bool8 EscalatorWarpEffect_6(struct Task * task); +void Escalator_AnimatePlayerGoingDown(struct Task * task); +void Escalator_AnimatePlayerGoingUp(struct Task * task); +void Escalator_BeginFadeOutToNewMap(void); +void Escalator_TransitionToWarpInEffect(void); +void FieldCB_EscalatorWarpIn(void); +void Task_EscalatorWarpInFieldEffect(u8 taskId); +bool8 EscalatorWarpInEffect_1(struct Task * task); +bool8 EscalatorWarpInEffect_2(struct Task * task); +bool8 EscalatorWarpInEffect_3(struct Task * task); +bool8 EscalatorWarpInEffect_4(struct Task * task); +bool8 EscalatorWarpInEffect_5(struct Task * task); +bool8 EscalatorWarpInEffect_6(struct Task * task); +bool8 EscalatorWarpInEffect_7(struct Task * task); + +bool8 (*const sEscalatorWarpFieldEffectFuncs[])(struct Task * task) = { + EscalatorWarpEffect_1, + EscalatorWarpEffect_2, + EscalatorWarpEffect_3, + EscalatorWarpEffect_4, + EscalatorWarpEffect_5, + EscalatorWarpEffect_6 +}; + +bool8 (*const sEscalatorWarpInFieldEffectFuncs[])(struct Task * task) = { + EscalatorWarpInEffect_1, + EscalatorWarpInEffect_2, + EscalatorWarpInEffect_3, + EscalatorWarpInEffect_4, + EscalatorWarpInEffect_5, + EscalatorWarpInEffect_6, + EscalatorWarpInEffect_7 +}; + +void StartEscalatorWarp(u8 metatileBehavior, u8 priority) +{ + u8 taskId = CreateTask(Task_EscalatorWarpFieldEffect, priority); + gTasks[taskId].data[1] = 0; + if (metatileBehavior == MB_UP_ESCALATOR) + gTasks[taskId].data[1] = 1; +} + +void Task_EscalatorWarpFieldEffect(u8 taskId) +{ + struct Task * task = &gTasks[taskId]; + while (sEscalatorWarpFieldEffectFuncs[task->data[0]](task)) + ; +} + +bool8 EscalatorWarpEffect_1(struct Task * task) +{ + FreezeObjectEvents(); + CameraObjectReset2(); + StartEscalator(task->data[1]); + sub_81128BC(1); + task->data[0]++; + return FALSE; +} + +bool8 EscalatorWarpEffect_2(struct Task * task) +{ + struct ObjectEvent * objectEvent; + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(GetPlayerFacingDirection())); + task->data[0]++; + task->data[2] = 0; + task->data[3] = 0; + if ((u8)task->data[1] == 0) + { + task->data[0] = 4; + } + PlaySE(SE_ESUKA); + } + return FALSE; +} + +bool8 EscalatorWarpEffect_3(struct Task * task) +{ + Escalator_AnimatePlayerGoingDown(task); + if (task->data[2] > 3) + { + Escalator_BeginFadeOutToNewMap(); + task->data[0]++; + } + return FALSE; +} + +bool8 EscalatorWarpEffect_4(struct Task * task) +{ + Escalator_AnimatePlayerGoingDown(task); + Escalator_TransitionToWarpInEffect(); + return FALSE; +} + +bool8 EscalatorWarpEffect_5(struct Task * task) +{ + Escalator_AnimatePlayerGoingUp(task); + if (task->data[2] > 3) + { + Escalator_BeginFadeOutToNewMap(); + task->data[0]++; + } + return FALSE; +} + +bool8 EscalatorWarpEffect_6(struct Task * task) +{ + Escalator_AnimatePlayerGoingUp(task); + Escalator_TransitionToWarpInEffect(); + return FALSE; +} + + +void Escalator_AnimatePlayerGoingDown(struct Task *task) +{ + struct Sprite *sprite; + sprite = &gSprites[gPlayerAvatar.spriteId]; + sprite->pos2.x = Cos(0x84, task->data[2]); + sprite->pos2.y = Sin(0x94, task->data[2]); + task->data[3]++; + if (task->data[3] & 1) + { + task->data[2]++; + } +} + +void Escalator_AnimatePlayerGoingUp(struct Task *task) +{ + struct Sprite *sprite; + sprite = &gSprites[gPlayerAvatar.spriteId]; + sprite->pos2.x = Cos(0x7c, task->data[2]); + sprite->pos2.y = Sin(0x76, task->data[2]); + task->data[3]++; + if (task->data[3] & 1) + { + task->data[2]++; + } +} + +void Escalator_BeginFadeOutToNewMap(void) +{ + TryFadeOutOldMapMusic(); + WarpFadeOutScreen(); +} + +void Escalator_TransitionToWarpInEffect(void) +{ + if (!gPaletteFade.active && BGMusicStopped() == TRUE) + { + StopEscalator(); + WarpIntoMap(); + gFieldCallback = FieldCB_EscalatorWarpIn; + SetMainCallback2(CB2_LoadMap); + DestroyTask(FindTaskIdByFunc(Task_EscalatorWarpFieldEffect)); + } +} + +void FieldCB_EscalatorWarpIn(void) +{ + Overworld_PlaySpecialMapMusic(); + pal_fill_for_maplights(); + sub_8111CF0(); + ScriptContext2_Enable(); + FreezeObjectEvents(); + CreateTask(Task_EscalatorWarpInFieldEffect, 0); + gFieldCallback = NULL; +} + +void Task_EscalatorWarpInFieldEffect(u8 taskId) +{ + struct Task * task = &gTasks[taskId]; + while (sEscalatorWarpInFieldEffectFuncs[task->data[0]](task)) + ; +} + +bool8 EscalatorWarpInEffect_1(struct Task *task) +{ + struct ObjectEvent *objectEvent; + s16 x; + s16 y; + u8 behavior; + CameraObjectReset2(); + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(DIR_EAST)); + PlayerGetDestCoords(&x, &y); + behavior = MapGridGetMetatileBehaviorAt(x, y); + task->data[0]++; + task->data[1] = 16; + if (behavior == MB_DOWN_ESCALATOR) + { + behavior = 1; + task->data[0] = 3; + } else + { + behavior = 0; + } + StartEscalator(behavior); + return TRUE; +} + +bool8 EscalatorWarpInEffect_2(struct Task *task) +{ + struct Sprite *sprite; + sprite = &gSprites[gPlayerAvatar.spriteId]; + sprite->pos2.x = Cos(0x84, task->data[1]); + sprite->pos2.y = Sin(0x94, task->data[1]); + task->data[0]++; + return FALSE; +} + +bool8 EscalatorWarpInEffect_3(struct Task *task) +{ + struct Sprite *sprite; + sprite = &gSprites[gPlayerAvatar.spriteId]; + sprite->pos2.x = Cos(0x84, task->data[1]); + sprite->pos2.y = Sin(0x94, task->data[1]); + task->data[2]++; + if (task->data[2] & 1) + { + task->data[1]--; + } + if (task->data[1] == 0) + { + sprite->pos2.x = 0; + sprite->pos2.y = 0; + task->data[0] = 5; + } + return FALSE; +} + + +bool8 EscalatorWarpInEffect_4(struct Task *task) +{ + struct Sprite *sprite; + sprite = &gSprites[gPlayerAvatar.spriteId]; + sprite->pos2.x = Cos(0x7c, task->data[1]); + sprite->pos2.y = Sin(0x76, task->data[1]); + task->data[0]++; + return FALSE; +} + +bool8 EscalatorWarpInEffect_5(struct Task *task) +{ + struct Sprite *sprite; + sprite = &gSprites[gPlayerAvatar.spriteId]; + sprite->pos2.x = Cos(0x7c, task->data[1]); + sprite->pos2.y = Sin(0x76, task->data[1]); + task->data[2]++; + if (task->data[2] & 1) + { + task->data[1]--; + } + if (task->data[1] == 0) + { + sprite->pos2.x = 0; + sprite->pos2.y = 0; + task->data[0]++; + } + return FALSE; +} + +bool8 EscalatorWarpInEffect_6(struct Task *task) +{ + if (IsEscalatorMoving()) + { + return FALSE; + } + StopEscalator(); + task->data[0]++; + return TRUE; +} + +bool8 EscalatorWarpInEffect_7(struct Task *task) +{ + struct ObjectEvent *objectEvent; + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + CameraObjectReset1(); + ScriptContext2_Disable(); + UnfreezeObjectEvents(); + ObjectEventSetHeldMovement(objectEvent, GetWalkNormalMovementAction(DIR_EAST)); + DestroyTask(FindTaskIdByFunc(Task_EscalatorWarpInFieldEffect)); + sub_81128BC(2); + } + return FALSE; +} -- cgit v1.2.3 From c117bc6864b951c1f6ea124aa8176e64ad25f5c8 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 10:19:34 -0500 Subject: Waterfall field effect --- src/field_effect.c | 83 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index a35fbfe7f..ff1e41146 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -12,6 +12,7 @@ #include "field_weather.h" #include "fieldmap.h" #include "help_system.h" +#include "metatile_behavior.h" #include "overworld.h" #include "party_menu.h" #include "quest_log.h" @@ -1528,3 +1529,85 @@ bool8 EscalatorWarpInEffect_7(struct Task *task) } return FALSE; } + +void Task_UseWaterfall(u8 taskId); + +bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj); +bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * playerObj); +bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEvent * playerObj); +bool8 waterfall_3_move_player_probably(struct Task * task, struct ObjectEvent * playerObj); +bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEvent * playerObj); + +bool8 (*const sUseWaterfallFieldEffectFuncs[])(struct Task * task, struct ObjectEvent * playerObj) = { + waterfall_0_setup, + waterfall_1_do_anim_probably, + waterfall_2_wait_anim_finish_probably, + waterfall_3_move_player_probably, + waterfall_4_wait_player_move_probably +}; + +u32 FldEff_UseWaterfall(void) +{ + u8 taskId = CreateTask(Task_UseWaterfall, 0xFF); + gTasks[taskId].data[1] = gFieldEffectArguments[0]; + Task_UseWaterfall(taskId); + return 0; +} + +void Task_UseWaterfall(u8 taskId) +{ + while (sUseWaterfallFieldEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId])) + ; +} + +bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj) +{ + ScriptContext2_Enable(); + gPlayerAvatar.preventStep = TRUE; + task->data[0]++; + return FALSE; +} + +bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * playerObj) +{ + ScriptContext2_Enable(); + if (!ObjectEventIsMovementOverridden(playerObj)) + { + ObjectEventClearHeldMovementIfFinished(playerObj); + gFieldEffectArguments[0] = task->data[1]; + FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT); + task->data[0]++; + } + return FALSE; +} + +bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEvent * playerObj) +{ + if (FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON)) + return FALSE; + task->data[0]++; + return TRUE; +} + +bool8 waterfall_3_move_player_probably(struct Task * task, struct ObjectEvent * playerObj) +{ + ObjectEventSetHeldMovement(playerObj, sub_8063F2C(DIR_NORTH)); + task->data[0]++; + return FALSE; +} + +bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEvent * playerObj) +{ + if (!ObjectEventClearHeldMovementIfFinished(playerObj)) + return FALSE; + if (MetatileBehavior_IsWaterfall(playerObj->mapobj_unk_1E)) + { + task->data[0] = 3; + return TRUE; + } + ScriptContext2_Disable(); + gPlayerAvatar.preventStep = FALSE; + DestroyTask(FindTaskIdByFunc(Task_UseWaterfall)); + FieldEffectActiveListRemove(FLDEFF_USE_WATERFALL); + return FALSE; +} -- cgit v1.2.3 From 8a092738468de1f4bbe11b7ef4d338735312e9dd Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 11:16:03 -0500 Subject: Unused dive field effect --- src/field_effect.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index ff1e41146..c848a43c5 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -5,6 +5,7 @@ #include "event_data.h" #include "event_object_movement.h" #include "field_camera.h" +#include "field_control_avatar.h" #include "field_effect.h" #include "field_effect_scripts.h" #include "field_fadetransition.h" @@ -1611,3 +1612,58 @@ bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEve FieldEffectActiveListRemove(FLDEFF_USE_WATERFALL); return FALSE; } + +void Task_Dive(u8 taskId); +bool8 dive_1_lock(struct Task * task); +bool8 dive_2_unknown(struct Task * task); +bool8 dive_3_unknown(struct Task * task); + +bool8 (*const sDiveFieldEffectFuncPtrs[])(struct Task * task) = { + dive_1_lock, + dive_2_unknown, + dive_3_unknown +}; + +u32 FldEff_UseDive(void) +{ + u8 taskId = CreateTask(Task_Dive, 0xFF); + gTasks[taskId].data[15] = gFieldEffectArguments[0]; + gTasks[taskId].data[14] = gFieldEffectArguments[1]; + Task_Dive(taskId); + return 0; +} + +void Task_Dive(u8 taskId) +{ + while (sDiveFieldEffectFuncPtrs[gTasks[taskId].data[0]](&gTasks[taskId])) + ; +} + +bool8 dive_1_lock(struct Task * task) +{ + gPlayerAvatar.preventStep = TRUE; + task->data[0]++; + return FALSE; +} + +bool8 dive_2_unknown(struct Task * task) +{ + ScriptContext2_Enable(); + gFieldEffectArguments[0] = task->data[15]; + FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT); + task->data[0]++; + return FALSE; +} + +bool8 dive_3_unknown(struct Task * task) +{ + struct MapPosition pos; + PlayerGetDestCoords(&pos.x, &pos.y); + if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON)) + { + dive_warp(&pos, gObjectEvents[gPlayerAvatar.objectEventId].mapobj_unk_1E); + DestroyTask(FindTaskIdByFunc(Task_Dive)); + FieldEffectActiveListRemove(FLDEFF_USE_DIVE); + } + return FALSE; +} -- cgit v1.2.3 From 9cf19244fa1fe925d4273eb32c8b7c68c5271152 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 13:18:21 -0500 Subject: Port Lavaridge Gym B1F Warp from Emerald --- src/field_effect.c | 211 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 209 insertions(+), 2 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index c848a43c5..5f07311e2 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -1099,7 +1099,7 @@ bool8 (*const sFallWarpEffectCBPtrs[])(struct Task * task) = { void FieldCB_FallWarpExit(void) { Overworld_PlaySpecialMapMusic(); - pal_fill_for_maplights(); + WarpFadeInScreen(); sub_8111CF0(); ScriptContext2_Enable(); FreezeObjectEvents(); @@ -1403,7 +1403,7 @@ void Escalator_TransitionToWarpInEffect(void) void FieldCB_EscalatorWarpIn(void) { Overworld_PlaySpecialMapMusic(); - pal_fill_for_maplights(); + WarpFadeInScreen(); sub_8111CF0(); ScriptContext2_Enable(); FreezeObjectEvents(); @@ -1667,3 +1667,210 @@ bool8 dive_3_unknown(struct Task * task) } return FALSE; } + +void Task_LavaridgeGymB1FWarp(u8 taskId); +bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +void FieldCB_LavaridgeGymB1FWarpExit(void); +void Task_LavaridgeGymB1FWarpExit(u8 taskId); +bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); + +bool8 (*const sLavaridgeGymB1FWarpEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { + LavaridgeGymB1FWarpEffect_1, + LavaridgeGymB1FWarpEffect_2, + LavaridgeGymB1FWarpEffect_3, + LavaridgeGymB1FWarpEffect_4, + LavaridgeGymB1FWarpEffect_5, + LavaridgeGymB1FWarpEffect_6 +}; + +bool8 (*const sLavaridgeGymB1FWarpExitEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { + LavaridgeGymB1FWarpExitEffect_1, + LavaridgeGymB1FWarpExitEffect_2, + LavaridgeGymB1FWarpExitEffect_3, + LavaridgeGymB1FWarpExitEffect_4 +}; + +void StartLavaridgeGymB1FWarp(u8 priority) +{ + CreateTask(Task_LavaridgeGymB1FWarp, priority); +} + +void Task_LavaridgeGymB1FWarp(u8 taskId) +{ + while (sLavaridgeGymB1FWarpEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId])); +} + +bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + FreezeObjectEvents(); + CameraObjectReset2(); + SetCameraPanningCallback(NULL); + gPlayerAvatar.preventStep = TRUE; + objectEvent->fixedPriority = 1; + task->data[1] = 1; + task->data[0]++; + return TRUE; +} + +bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + SetCameraPanning(0, task->data[1]); + task->data[1] = -task->data[1]; + task->data[2]++; + if (task->data[2] > 7) + { + task->data[2] = 0; + task->data[0]++; + } + return FALSE; +} + +bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + sprite->pos2.y = 0; + task->data[3] = 1; + gFieldEffectArguments[0] = objectEvent->currentCoords.x; + gFieldEffectArguments[1] = objectEvent->currentCoords.y; + gFieldEffectArguments[2] = sprite->subpriority - 1; + gFieldEffectArguments[3] = sprite->oam.priority; + FieldEffectStart(FLDEFF_LAVARIDGE_GYM_WARP); + PlaySE(SE_W153); + task->data[0]++; + return TRUE; +} + +bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + s16 centerToCornerVecY; + SetCameraPanning(0, task->data[1]); + if (task->data[1] = -task->data[1], ++task->data[2] <= 17) + { + if (!(task->data[2] & 1) && (task->data[1] <= 3)) + { + task->data[1] <<= 1; + } + } else if (!(task->data[2] & 4) && (task->data[1] > 0)) + { + task->data[1] >>= 1; + } + if (task->data[2] > 6) + { + centerToCornerVecY = -(sprite->centerToCornerVecY << 1); + if (sprite->pos2.y > -(sprite->pos1.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY + centerToCornerVecY)) + { + sprite->pos2.y -= task->data[3]; + if (task->data[3] <= 7) + { + task->data[3]++; + } + } else + { + task->data[4] = 1; + } + } + if (task->data[5] == 0 && sprite->pos2.y < -0x10) + { + task->data[5]++; + objectEvent->fixedPriority = 1; + sprite->oam.priority = 1; + sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY; + } + if (task->data[1] == 0 && task->data[4] != 0) + { + task->data[0]++; + } + return FALSE; +} + +bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + TryFadeOutOldMapMusic(); + WarpFadeOutScreen(); + task->data[0]++; + return FALSE; +} + +bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + if (!gPaletteFade.active && BGMusicStopped() == TRUE) + { + WarpIntoMap(); + gFieldCallback = FieldCB_LavaridgeGymB1FWarpExit; + SetMainCallback2(CB2_LoadMap); + DestroyTask(FindTaskIdByFunc(Task_LavaridgeGymB1FWarp)); + } + return FALSE; +} + +void FieldCB_LavaridgeGymB1FWarpExit(void) +{ + Overworld_PlaySpecialMapMusic(); + WarpFadeInScreen(); + sub_8111CF0(); + ScriptContext2_Enable(); + gFieldCallback = NULL; + CreateTask(Task_LavaridgeGymB1FWarpExit, 0); +} + +void Task_LavaridgeGymB1FWarpExit(u8 taskId) +{ + while (sLavaridgeGymB1FWarpExitEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId])); +} + +bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + CameraObjectReset2(); + FreezeObjectEvents(); + gPlayerAvatar.preventStep = TRUE; + objectEvent->invisible = TRUE; + task->data[0]++; + return FALSE; +} + +bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + if (IsWeatherNotFadingIn()) + { + gFieldEffectArguments[0] = objectEvent->currentCoords.x; + gFieldEffectArguments[1] = objectEvent->currentCoords.y; + gFieldEffectArguments[2] = sprite->subpriority - 1; + gFieldEffectArguments[3] = sprite->oam.priority; + task->data[1] = FieldEffectStart(FLDEFF_POP_OUT_OF_ASH); + task->data[0]++; + } + return FALSE; +} + +bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + sprite = &gSprites[task->data[1]]; + if (sprite->animCmdIndex > 1) + { + task->data[0]++; + objectEvent->invisible = FALSE; + CameraObjectReset1(); + PlaySE(SE_W091); + ObjectEventSetHeldMovement(objectEvent, sub_8064194(DIR_EAST)); + } + return FALSE; +} + +bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +{ + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + gPlayerAvatar.preventStep = FALSE; + ScriptContext2_Disable(); + UnfreezeObjectEvents(); + DestroyTask(FindTaskIdByFunc(Task_LavaridgeGymB1FWarpExit)); + } + return FALSE; +} -- cgit v1.2.3 From 8f42b7b56d887b6bca517499a841c259652af372 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 13:23:51 -0500 Subject: Lavaridge Gym 1F Warp field effect --- src/field_effect.c | 109 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 5f07311e2..81ba91b1c 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -1874,3 +1874,112 @@ bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * o } return FALSE; } + +void Task_LavaridgeGym1FWarp(u8 taskId); +bool8 LavaridgeGym1FWarpEffect_1(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); +bool8 LavaridgeGym1FWarpEffect_2(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); +bool8 LavaridgeGym1FWarpEffect_3(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); +bool8 LavaridgeGym1FWarpEffect_4(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); +bool8 LavaridgeGym1FWarpEffect_5(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); + +bool8 (*const sLavaridgeGym1FWarpEffectFuncs[])(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) = { + LavaridgeGym1FWarpEffect_1, + LavaridgeGym1FWarpEffect_2, + LavaridgeGym1FWarpEffect_3, + LavaridgeGym1FWarpEffect_4, + LavaridgeGym1FWarpEffect_5 +}; + +// For the ash puff effect when warping off the B1F ash tiles +u8 FldEff_LavaridgeGymWarp(void) +{ + u8 spriteId; + sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[33], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + gSprites[spriteId].oam.priority = gFieldEffectArguments[3]; + gSprites[spriteId].coordOffsetEnabled = 1; + return spriteId; +} + +void SpriteCB_LavaridgeGymWarp(struct Sprite *sprite) +{ + if (sprite->animEnded) + { + FieldEffectStop(sprite, FLDEFF_LAVARIDGE_GYM_WARP); + } +} + +void StartLavaridgeGym1FWarp(u8 priority) +{ + CreateTask(Task_LavaridgeGym1FWarp, priority); +} + +void Task_LavaridgeGym1FWarp(u8 taskId) +{ + while(sLavaridgeGym1FWarpEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId])); +} + +bool8 LavaridgeGym1FWarpEffect_1(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +{ + FreezeObjectEvents(); + CameraObjectReset2(); + gPlayerAvatar.preventStep = TRUE; + objectEvent->fixedPriority = 1; + task->data[0]++; + return FALSE; +} + +bool8 LavaridgeGym1FWarpEffect_2(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +{ + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + if (task->data[1] > 3) + { + gFieldEffectArguments[0] = objectEvent->currentCoords.x; + gFieldEffectArguments[1] = objectEvent->currentCoords.y; + gFieldEffectArguments[2] = sprite->subpriority - 1; + gFieldEffectArguments[3] = sprite->oam.priority; + task->data[1] = FieldEffectStart(FLDEFF_POP_OUT_OF_ASH); + task->data[0]++; + } else + { + task->data[1]++; + ObjectEventSetHeldMovement(objectEvent, GetStepInPlaceDelay4AnimId(objectEvent->facingDirection)); + PlaySE(SE_FU_ZUZUZU); + } + } + return FALSE; +} + +bool8 LavaridgeGym1FWarpEffect_3(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +{ + if (gSprites[task->data[1]].animCmdIndex == 2) + { + objectEvent->invisible = TRUE; + task->data[0]++; + } + return FALSE; +} + +bool8 LavaridgeGym1FWarpEffect_4(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +{ + if (!FieldEffectActiveListContains(FLDEFF_POP_OUT_OF_ASH)) + { + TryFadeOutOldMapMusic(); + WarpFadeOutScreen(); + task->data[0]++; + } + return FALSE; +} + +bool8 LavaridgeGym1FWarpEffect_5(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +{ + if (!gPaletteFade.active && BGMusicStopped() == TRUE) + { + WarpIntoMap(); + gFieldCallback = FieldCB_FallWarpExit; + SetMainCallback2(CB2_LoadMap); + DestroyTask(FindTaskIdByFunc(Task_LavaridgeGym1FWarp)); + } + return FALSE; +} -- cgit v1.2.3 From fb56341fe4fedeeca53b17fc693b4b3dd7824ff2 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 14:14:34 -0500 Subject: Escape Rope field effect --- src/field_effect.c | 246 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 246 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 81ba91b1c..4886a4729 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -1983,3 +1983,249 @@ bool8 LavaridgeGym1FWarpEffect_5(struct Task *task, struct ObjectEvent *objectEv } return FALSE; } + +u8 FldEff_PopOutOfAsh(void) +{ + u8 spriteId; + sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); + spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[32], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + gSprites[spriteId].oam.priority = gFieldEffectArguments[3]; + gSprites[spriteId].coordOffsetEnabled = 1; + return spriteId; +} + +void SpriteCB_PopOutOfAsh(struct Sprite *sprite) +{ + if (sprite->animEnded) + { + FieldEffectStop(sprite, FLDEFF_POP_OUT_OF_ASH); + } +} + +void Task_DoEscapeRopeFieldEffect(u8 taskId); +void EscapeRopeFieldEffect_Step0(struct Task * task); +void EscapeRopeFieldEffect_Step1(struct Task * task); +u8 sub_808576C(struct ObjectEvent * playerObj, s16 *a1p, s16 *a2p); +bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *a1p, s16 *a2p); +void FieldCallback_EscapeRopeExit(void); +void Task_DoEscapeRopeExitFieldEffect(u8 taskId); +void EscapeRopeExitFieldEffect_Step0(struct Task * task); +void EscapeRopeExitFieldEffect_Step1(struct Task * task); + +void (*const gEscapeRopeFieldEffectFuncs[])(struct Task * task) = { + EscapeRopeFieldEffect_Step0, + EscapeRopeFieldEffect_Step1 +}; + +const u8 gUnknown_83CC0E8[] = { + [DIR_NONE] = DIR_SOUTH, + [DIR_SOUTH] = DIR_WEST, + [DIR_WEST] = DIR_NORTH, + [DIR_NORTH] = DIR_EAST, + [DIR_EAST] = DIR_SOUTH, +}; + +void (*const sEscapeRopeExitEffectFuncs[])(struct Task * task) = { + EscapeRopeExitFieldEffect_Step0, + EscapeRopeExitFieldEffect_Step1 +}; + +void StartEscapeRopeFieldEffect(void) +{ + ScriptContext2_Enable(); + FreezeObjectEvents(); + CreateTask(Task_DoEscapeRopeFieldEffect, 80); +} + +void Task_DoEscapeRopeFieldEffect(u8 taskId) +{ + gEscapeRopeFieldEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void EscapeRopeFieldEffect_Step0(struct Task * task) +{ + task->data[0]++; + task->data[13] = 64; + task->data[14] = GetPlayerFacingDirection(); + task->data[15] = 0; +} + +void EscapeRopeFieldEffect_Step1(struct Task * task) +{ + struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; + s16 *data = task->data; + sub_808576C(playerObj, &task->data[1], &task->data[2]); + if (data[3] < 60) + { + data[3]++; + if (data[3] == 20) + { + PlaySE(SE_TK_WARPIN); + } + } + else if (data[4] == 0 && !sub_80857F0(playerObj, &task->data[5], &task->data[6])) + { + TryFadeOutOldMapMusic(); + WarpFadeOutScreen(); + data[4] = 1; + } + if (data[4] == 1 && !gPaletteFade.active && BGMusicStopped() == TRUE) + { + ObjectEventSetDirection(playerObj, task->data[15]); + sub_80555E0(); + WarpIntoMap(); + gFieldCallback = FieldCallback_EscapeRopeExit; + SetMainCallback2(CB2_LoadMap); + DestroyTask(FindTaskIdByFunc(Task_DoEscapeRopeFieldEffect)); + } +} + + +u8 sub_808576C(struct ObjectEvent * playerObj, s16 *delay_p, s16 *stage_p) +{ + if (!ObjectEventIsMovementOverridden(playerObj) || ObjectEventClearHeldMovementIfFinished(playerObj)) + { + if (*delay_p != 0 && --(*delay_p) != 0) + return playerObj->facingDirection; + ObjectEventSetHeldMovement(playerObj, GetFaceDirectionMovementAction(gUnknown_83CC0E8[playerObj->facingDirection])); + if (*stage_p < 12) + (*stage_p)++; + *delay_p = 12 >> (*stage_p); // 12 >> 4 = 0 + return gUnknown_83CC0E8[playerObj->facingDirection]; + } + return playerObj->facingDirection; +} + +bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p) +{ + struct Sprite * sprite = &gSprites[playerObj->spriteId]; + switch (*state_p) + { + case 0: + CameraObjectReset2(); + (*state_p)++; + // fallthrough + case 1: + sprite->pos2.y -= 8; + (*y_p) -= 8; + if (*y_p <= -16) + { + playerObj->fixedPriority = TRUE; + sprite->oam.priority = 1; + sprite->subpriority = 0; + sprite->subspriteMode = SUBSPRITES_OFF; + (*state_p)++; + } + break; + case 2: + sprite->pos2.y -= 8; + (*y_p) -= 8; + if (*y_p <= -88) + { + (*state_p)++; + return FALSE; + } + break; + case 3: + return FALSE; + } + return TRUE; +} + +bool32 sub_80858A4(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p, s16 *priority_p, s16 *subpriority_p, s16 *subspriteMode_p) +{ + struct Sprite * sprite = &gSprites[playerObj->spriteId]; + switch (*state_p) + { + case 0: + CameraObjectReset2(); + *y_p = -88; + sprite->pos2.y -= 88; + *priority_p = sprite->oam.priority; + *subpriority_p = sprite->subpriority; + *subspriteMode_p = sprite->subspriteMode; + playerObj->fixedPriority = TRUE; + sprite->oam.priority = 1; + sprite->subpriority = 0; + sprite->subspriteMode = SUBSPRITES_OFF; + (*state_p)++; + // fallthrough + case 1: + sprite->pos2.y += 4; + (*y_p) += 4; + if (*y_p >= -16) + { + sprite->oam.priority = *priority_p; + sprite->subpriority = *subpriority_p; + sprite->subspriteMode = *subspriteMode_p; + (*state_p)++; + } + break; + case 2: + sprite->pos2.y += 4; + (*y_p) += 4; + if (*y_p >= 0) + { + PlaySE(SE_TK_KASYA); + CameraObjectReset1(); + (*state_p)++; + return FALSE; + } + break; + case 3: + return FALSE; + } + return TRUE; +} + +void FieldCallback_EscapeRopeExit(void) +{ + Overworld_PlaySpecialMapMusic(); + WarpFadeInScreen(); + sub_8111CF0(); + ScriptContext2_Enable(); + FreezeObjectEvents(); + gFieldCallback = NULL; + gObjectEvents[gPlayerAvatar.objectEventId].invisible = TRUE; + CreateTask(Task_DoEscapeRopeExitFieldEffect, 0); +} + +void Task_DoEscapeRopeExitFieldEffect(u8 taskId) +{ + sEscapeRopeExitEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void EscapeRopeExitFieldEffect_Step0(struct Task * task) +{ + if (IsWeatherNotFadingIn()) + { + PlaySE(SE_TK_WARPOUT); + task->data[15] = GetPlayerFacingDirection(); + task->data[0]++; + } +} + +void EscapeRopeExitFieldEffect_Step1(struct Task * task) +{ + s16 *data = task->data; + struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; + bool32 finished = sub_80858A4(playerObj, &data[1], &data[2], &data[3], &data[4], &data[5]); + playerObj->invisible = FALSE; + if (data[6] < 8) + data[6]++; + else if (data[7] == 0) + { + data[6]++; + data[8] = sub_808576C(playerObj, &data[9], &data[10]); + if (data[6] >= 50 && data[8] == data[15]) + data[7] = 1; + } + if (!finished && data[8] == data[15] && ObjectEventCheckHeldMovementStatus(playerObj) == TRUE) + { + playerObj->invisible = FALSE; + playerObj->fixedPriority = FALSE; + ScriptContext2_Disable(); + UnfreezeObjectEvents(); + DestroyTask(FindTaskIdByFunc(Task_DoEscapeRopeExitFieldEffect)); + } +} -- cgit v1.2.3 From 410aaa00ff6bb8d0e9dae755b60e216be24b9660 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 14:26:54 -0500 Subject: Teleport field effect --- src/field_effect.c | 265 +++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 235 insertions(+), 30 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 4886a4729..6657265dd 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -1265,16 +1265,6 @@ bool8 (*const sEscalatorWarpFieldEffectFuncs[])(struct Task * task) = { EscalatorWarpEffect_6 }; -bool8 (*const sEscalatorWarpInFieldEffectFuncs[])(struct Task * task) = { - EscalatorWarpInEffect_1, - EscalatorWarpInEffect_2, - EscalatorWarpInEffect_3, - EscalatorWarpInEffect_4, - EscalatorWarpInEffect_5, - EscalatorWarpInEffect_6, - EscalatorWarpInEffect_7 -}; - void StartEscalatorWarp(u8 metatileBehavior, u8 priority) { u8 taskId = CreateTask(Task_EscalatorWarpFieldEffect, priority); @@ -1400,6 +1390,16 @@ void Escalator_TransitionToWarpInEffect(void) } } +bool8 (*const sEscalatorWarpInFieldEffectFuncs[])(struct Task * task) = { + EscalatorWarpInEffect_1, + EscalatorWarpInEffect_2, + EscalatorWarpInEffect_3, + EscalatorWarpInEffect_4, + EscalatorWarpInEffect_5, + EscalatorWarpInEffect_6, + EscalatorWarpInEffect_7 +}; + void FieldCB_EscalatorWarpIn(void) { Overworld_PlaySpecialMapMusic(); @@ -1691,13 +1691,6 @@ bool8 (*const sLavaridgeGymB1FWarpEffectFuncs[])(struct Task * task, struct Obje LavaridgeGymB1FWarpEffect_6 }; -bool8 (*const sLavaridgeGymB1FWarpExitEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { - LavaridgeGymB1FWarpExitEffect_1, - LavaridgeGymB1FWarpExitEffect_2, - LavaridgeGymB1FWarpExitEffect_3, - LavaridgeGymB1FWarpExitEffect_4 -}; - void StartLavaridgeGymB1FWarp(u8 priority) { CreateTask(Task_LavaridgeGymB1FWarp, priority); @@ -1810,6 +1803,13 @@ bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objec return FALSE; } +bool8 (*const sLavaridgeGymB1FWarpExitEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { + LavaridgeGymB1FWarpExitEffect_1, + LavaridgeGymB1FWarpExitEffect_2, + LavaridgeGymB1FWarpExitEffect_3, + LavaridgeGymB1FWarpExitEffect_4 +}; + void FieldCB_LavaridgeGymB1FWarpExit(void) { Overworld_PlaySpecialMapMusic(); @@ -2017,19 +2017,6 @@ void (*const gEscapeRopeFieldEffectFuncs[])(struct Task * task) = { EscapeRopeFieldEffect_Step1 }; -const u8 gUnknown_83CC0E8[] = { - [DIR_NONE] = DIR_SOUTH, - [DIR_SOUTH] = DIR_WEST, - [DIR_WEST] = DIR_NORTH, - [DIR_NORTH] = DIR_EAST, - [DIR_EAST] = DIR_SOUTH, -}; - -void (*const sEscapeRopeExitEffectFuncs[])(struct Task * task) = { - EscapeRopeExitFieldEffect_Step0, - EscapeRopeExitFieldEffect_Step1 -}; - void StartEscapeRopeFieldEffect(void) { ScriptContext2_Enable(); @@ -2080,6 +2067,13 @@ void EscapeRopeFieldEffect_Step1(struct Task * task) } } +const u8 gUnknown_83CC0E8[] = { + [DIR_NONE] = DIR_SOUTH, + [DIR_SOUTH] = DIR_WEST, + [DIR_WEST] = DIR_NORTH, + [DIR_NORTH] = DIR_EAST, + [DIR_EAST] = DIR_SOUTH, +}; u8 sub_808576C(struct ObjectEvent * playerObj, s16 *delay_p, s16 *stage_p) { @@ -2132,6 +2126,11 @@ bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p) return TRUE; } +void (*const sEscapeRopeExitEffectFuncs[])(struct Task * task) = { + EscapeRopeExitFieldEffect_Step0, + EscapeRopeExitFieldEffect_Step1 +}; + bool32 sub_80858A4(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p, s16 *priority_p, s16 *subpriority_p, s16 *subspriteMode_p) { struct Sprite * sprite = &gSprites[playerObj->spriteId]; @@ -2229,3 +2228,209 @@ void EscapeRopeExitFieldEffect_Step1(struct Task * task) DestroyTask(FindTaskIdByFunc(Task_DoEscapeRopeExitFieldEffect)); } } + +void Task_DoTeleportFieldEffect(u8 taskId); +void TeleportFieldEffectTask1(struct Task * task); +void TeleportFieldEffectTask2(struct Task * task); +void TeleportFieldEffectTask3(struct Task * task); +void TeleportFieldEffectTask4(struct Task * task); +void FieldCallback_TeleportIn(void); +void Task_DoTeleportInFieldEffect(u8 taskId); +void TeleportInFieldEffectTask1(struct Task * task); +void TeleportInFieldEffectTask2(struct Task * task); +void TeleportInFieldEffectTask3(struct Task * task); + +void (*const sTeleportEffectFuncs[])(struct Task *) = { + TeleportFieldEffectTask1, + TeleportFieldEffectTask2, + TeleportFieldEffectTask3, + TeleportFieldEffectTask4 +}; + +void CreateTeleportFieldEffectTask(void) +{ + CreateTask(Task_DoTeleportFieldEffect, 0); +} + +void Task_DoTeleportFieldEffect(u8 taskId) +{ + sTeleportEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void TeleportFieldEffectTask1(struct Task *task) +{ + ScriptContext2_Enable(); + FreezeObjectEvents(); + CameraObjectReset2(); + task->data[15] = GetPlayerFacingDirection(); + task->data[0]++; +} + +void TeleportFieldEffectTask2(struct Task *task) +{ + u8 spinDirections[5] = { + [DIR_NONE] = DIR_SOUTH, + [DIR_SOUTH] = DIR_WEST, + [DIR_WEST] = DIR_NORTH, + [DIR_NORTH] = DIR_EAST, + [DIR_EAST] = DIR_SOUTH + }; + struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (task->data[1] == 0 || (--task->data[1]) == 0) + { + ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]); + task->data[1] = 8; + task->data[2]++; + } + if (task->data[2] > 7 && task->data[15] == objectEvent->facingDirection) + { + task->data[0]++; + task->data[1] = 4; + task->data[2] = 8; + task->data[3] = 1; + PlaySE(SE_TK_WARPIN); + } +} + +void TeleportFieldEffectTask3(struct Task *task) +{ + u8 spinDirections[5] = {DIR_SOUTH, DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH}; + struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + struct Sprite *sprite = &gSprites[gPlayerAvatar.spriteId]; + if ((--task->data[1]) <= 0) + { + task->data[1] = 4; + ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]); + } + sprite->pos1.y -= task->data[3]; + task->data[4] += task->data[3]; + if ((--task->data[2]) <= 0 && (task->data[2] = 4, task->data[3] < 8)) + { + task->data[3] <<= 1; + } + if (task->data[4] > 8 && (sprite->oam.priority = 1, sprite->subspriteMode != SUBSPRITES_OFF)) + { + sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY; + } + if (task->data[4] >= 0xa8) + { + task->data[0]++; + TryFadeOutOldMapMusic(); + WarpFadeOutScreen(); + } +} + +void TeleportFieldEffectTask4(struct Task *task) +{ + if (!gPaletteFade.active) + { + if (BGMusicStopped() == TRUE) + { + copy_saved_warp3_bank_and_enter_x_to_warp1(); + WarpIntoMap(); + SetMainCallback2(CB2_LoadMap); + gFieldCallback = FieldCallback_TeleportIn; + DestroyTask(FindTaskIdByFunc(Task_DoTeleportFieldEffect)); + } + } +} + +void (*const sTeleportInEffectFuncs[])(struct Task *) = { + TeleportInFieldEffectTask1, + TeleportInFieldEffectTask2, + TeleportInFieldEffectTask3 +}; + +void FieldCallback_TeleportIn(void) +{ + Overworld_PlaySpecialMapMusic(); + WarpFadeInScreen(); + sub_8111CF0(); + ScriptContext2_Enable(); + FreezeObjectEvents(); + gFieldCallback = NULL; + gObjectEvents[gPlayerAvatar.objectEventId].invisible = TRUE; + CameraObjectReset2(); + CreateTask(Task_DoTeleportInFieldEffect, 0); +} + +void Task_DoTeleportInFieldEffect(u8 taskId) +{ + sTeleportInEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void TeleportInFieldEffectTask1(struct Task *task) +{ + struct Sprite *sprite; + s16 centerToCornerVecY; + if (IsWeatherNotFadingIn()) + { + sprite = &gSprites[gPlayerAvatar.spriteId]; + centerToCornerVecY = -(sprite->centerToCornerVecY << 1); + sprite->pos2.y = -(sprite->pos1.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY + centerToCornerVecY); + gObjectEvents[gPlayerAvatar.objectEventId].invisible = FALSE; + task->data[0]++; + task->data[1] = 8; + task->data[2] = 1; + task->data[14] = sprite->subspriteMode; + task->data[15] = GetPlayerFacingDirection(); + PlaySE(SE_TK_WARPIN); + } +} + +void TeleportInFieldEffectTask2(struct Task *task) +{ + u8 spinDirections[5] = {1, 3, 4, 2, 1}; + struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + struct Sprite *sprite = &gSprites[gPlayerAvatar.spriteId]; + if ((sprite->pos2.y += task->data[1]) >= -8) + { + if (task->data[13] == 0) + { + task->data[13]++; + objectEvent->triggerGroundEffectsOnMove = 1; + sprite->subspriteMode = task->data[14]; + } + } else + { + sprite->oam.priority = 1; + if (sprite->subspriteMode != SUBSPRITES_OFF) + { + sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY; + } + } + if (sprite->pos2.y >= -0x30 && task->data[1] > 1 && !(sprite->pos2.y & 1)) + { + task->data[1]--; + } + if ((--task->data[2]) == 0) + { + task->data[2] = 4; + ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]); + } + if (sprite->pos2.y >= 0) + { + sprite->pos2.y = 0; + task->data[0]++; + task->data[1] = 1; + task->data[2] = 0; + } +} + +void TeleportInFieldEffectTask3(struct Task *task) +{ + u8 spinDirections[5] = {1, 3, 4, 2, 1}; + struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if ((--task->data[1]) == 0) + { + ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]); + task->data[1] = 8; + if ((++task->data[2]) > 4 && task->data[14] == objectEvent->facingDirection) + { + ScriptContext2_Disable(); + CameraObjectReset1(); + UnfreezeObjectEvents(); + DestroyTask(FindTaskIdByFunc(Task_DoTeleportInFieldEffect)); + } + } +} -- cgit v1.2.3 From 0c492c087eca215e7dd29a90b8a3e9232ffe3bf6 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 15:19:50 -0500 Subject: Show Mon field effect --- src/field_effect.c | 541 +++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 486 insertions(+), 55 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 6657265dd..ecdc834ae 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -14,6 +14,7 @@ #include "fieldmap.h" #include "help_system.h" #include "metatile_behavior.h" +#include "new_menu_helpers.h" #include "overworld.h" #include "party_menu.h" #include "quest_log.h" @@ -22,6 +23,7 @@ #include "task.h" #include "trainer_pokemon_sprites.h" #include "trig.h" +#include "util.h" #include "constants/metatile_behaviors.h" #include "constants/songs.h" @@ -57,12 +59,12 @@ const u16 gUnknown_83CAFB0[] = INCBIN_U16("graphics/field_effects/unk_83CAFB0.gb const u16 gUnknown_83CAFD0[] = INCBIN_U16("graphics/field_effects/unk_83CAFD0.4bpp"); const u16 gUnknown_83CB3D0[] = INCBIN_U16("graphics/field_effects/unk_83CB3D0.gbapal"); const u16 gUnknown_83CB3F0[] = INCBIN_U16("graphics/field_effects/unk_83CB3F0.4bpp"); -const u16 gUnknown_83CB5F0[] = INCBIN_U16("graphics/field_effects/unk_83CB5F0.4bpp"); -const u16 gUnknown_83CB7F0[] = INCBIN_U16("graphics/field_effects/unk_83CB7F0.gbapal"); -const u16 gUnknown_83CB810[] = INCBIN_U16("graphics/field_effects/unk_83CB810.bin"); -const u16 gUnknown_83CBA90[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp"); -const u16 gUnknown_83CBB10[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal"); -const u16 gUnknown_83CBB30[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin"); +const u16 gFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CB5F0.4bpp"); +const u16 gFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CB7F0.gbapal"); +const u16 gFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CB810.bin"); +const u16 gDarknessFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp"); +const u16 gDarknessFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal"); +const u16 gDarknessFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin"); const u16 gUnknown_83CBDB0[] = INCBIN_U16("graphics/field_effects/unk_83CBDB0.4bpp"); bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = { @@ -591,10 +593,10 @@ u8 CreateMonSprite_PicBox(u16 species, s16 x, s16 y, u8 subpriority) return spriteId; } -u8 CreateMonSprite_FieldMove(u16 species, u32 d, u32 g, s16 x, s16 y, u8 subpriority) +u8 CreateMonSprite_FieldMove(u16 species, u32 otId, u32 personality, s16 x, s16 y, u8 subpriority) { - const struct CompressedSpritePalette * spritePalette = GetMonSpritePalStructFromOtIdPersonality(species, d, g); - u16 spriteId = CreateMonPicSprite_HandleDeoxys(species, d, g, 1, x, y, 0, spritePalette->tag); + const struct CompressedSpritePalette * spritePalette = GetMonSpritePalStructFromOtIdPersonality(species, otId, personality); + u16 spriteId = CreateMonPicSprite_HandleDeoxys(species, otId, personality, 1, x, y, 0, spritePalette->tag); PreservePaletteInWeather(IndexOfSpritePaletteTag(spritePalette->tag) + 0x10); if (spriteId == 0xFFFF) return MAX_SPRITES; @@ -1346,9 +1348,9 @@ bool8 EscalatorWarpEffect_6(struct Task * task) } -void Escalator_AnimatePlayerGoingDown(struct Task *task) +void Escalator_AnimatePlayerGoingDown(struct Task * task) { - struct Sprite *sprite; + struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; sprite->pos2.x = Cos(0x84, task->data[2]); sprite->pos2.y = Sin(0x94, task->data[2]); @@ -1359,9 +1361,9 @@ void Escalator_AnimatePlayerGoingDown(struct Task *task) } } -void Escalator_AnimatePlayerGoingUp(struct Task *task) +void Escalator_AnimatePlayerGoingUp(struct Task * task) { - struct Sprite *sprite; + struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; sprite->pos2.x = Cos(0x7c, task->data[2]); sprite->pos2.y = Sin(0x76, task->data[2]); @@ -1418,9 +1420,9 @@ void Task_EscalatorWarpInFieldEffect(u8 taskId) ; } -bool8 EscalatorWarpInEffect_1(struct Task *task) +bool8 EscalatorWarpInEffect_1(struct Task * task) { - struct ObjectEvent *objectEvent; + struct ObjectEvent * objectEvent; s16 x; s16 y; u8 behavior; @@ -1443,9 +1445,9 @@ bool8 EscalatorWarpInEffect_1(struct Task *task) return TRUE; } -bool8 EscalatorWarpInEffect_2(struct Task *task) +bool8 EscalatorWarpInEffect_2(struct Task * task) { - struct Sprite *sprite; + struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; sprite->pos2.x = Cos(0x84, task->data[1]); sprite->pos2.y = Sin(0x94, task->data[1]); @@ -1453,9 +1455,9 @@ bool8 EscalatorWarpInEffect_2(struct Task *task) return FALSE; } -bool8 EscalatorWarpInEffect_3(struct Task *task) +bool8 EscalatorWarpInEffect_3(struct Task * task) { - struct Sprite *sprite; + struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; sprite->pos2.x = Cos(0x84, task->data[1]); sprite->pos2.y = Sin(0x94, task->data[1]); @@ -1474,9 +1476,9 @@ bool8 EscalatorWarpInEffect_3(struct Task *task) } -bool8 EscalatorWarpInEffect_4(struct Task *task) +bool8 EscalatorWarpInEffect_4(struct Task * task) { - struct Sprite *sprite; + struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; sprite->pos2.x = Cos(0x7c, task->data[1]); sprite->pos2.y = Sin(0x76, task->data[1]); @@ -1484,9 +1486,9 @@ bool8 EscalatorWarpInEffect_4(struct Task *task) return FALSE; } -bool8 EscalatorWarpInEffect_5(struct Task *task) +bool8 EscalatorWarpInEffect_5(struct Task * task) { - struct Sprite *sprite; + struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; sprite->pos2.x = Cos(0x7c, task->data[1]); sprite->pos2.y = Sin(0x76, task->data[1]); @@ -1504,7 +1506,7 @@ bool8 EscalatorWarpInEffect_5(struct Task *task) return FALSE; } -bool8 EscalatorWarpInEffect_6(struct Task *task) +bool8 EscalatorWarpInEffect_6(struct Task * task) { if (IsEscalatorMoving()) { @@ -1515,9 +1517,9 @@ bool8 EscalatorWarpInEffect_6(struct Task *task) return TRUE; } -bool8 EscalatorWarpInEffect_7(struct Task *task) +bool8 EscalatorWarpInEffect_7(struct Task * task) { - struct ObjectEvent *objectEvent; + struct ObjectEvent * objectEvent; objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; if (ObjectEventClearHeldMovementIfFinished(objectEvent)) { @@ -1876,13 +1878,13 @@ bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * o } void Task_LavaridgeGym1FWarp(u8 taskId); -bool8 LavaridgeGym1FWarpEffect_1(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 LavaridgeGym1FWarpEffect_2(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 LavaridgeGym1FWarpEffect_3(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 LavaridgeGym1FWarpEffect_4(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 LavaridgeGym1FWarpEffect_5(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite); +bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +bool8 LavaridgeGym1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 (*const sLavaridgeGym1FWarpEffectFuncs[])(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) = { +bool8 (*const sLavaridgeGym1FWarpEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { LavaridgeGym1FWarpEffect_1, LavaridgeGym1FWarpEffect_2, LavaridgeGym1FWarpEffect_3, @@ -1901,7 +1903,7 @@ u8 FldEff_LavaridgeGymWarp(void) return spriteId; } -void SpriteCB_LavaridgeGymWarp(struct Sprite *sprite) +void SpriteCB_LavaridgeGymWarp(struct Sprite * sprite) { if (sprite->animEnded) { @@ -1919,7 +1921,7 @@ void Task_LavaridgeGym1FWarp(u8 taskId) while(sLavaridgeGym1FWarpEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId])); } -bool8 LavaridgeGym1FWarpEffect_1(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { FreezeObjectEvents(); CameraObjectReset2(); @@ -1929,7 +1931,7 @@ bool8 LavaridgeGym1FWarpEffect_1(struct Task *task, struct ObjectEvent *objectEv return FALSE; } -bool8 LavaridgeGym1FWarpEffect_2(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (ObjectEventClearHeldMovementIfFinished(objectEvent)) { @@ -1951,7 +1953,7 @@ bool8 LavaridgeGym1FWarpEffect_2(struct Task *task, struct ObjectEvent *objectEv return FALSE; } -bool8 LavaridgeGym1FWarpEffect_3(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (gSprites[task->data[1]].animCmdIndex == 2) { @@ -1961,7 +1963,7 @@ bool8 LavaridgeGym1FWarpEffect_3(struct Task *task, struct ObjectEvent *objectEv return FALSE; } -bool8 LavaridgeGym1FWarpEffect_4(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (!FieldEffectActiveListContains(FLDEFF_POP_OUT_OF_ASH)) { @@ -1972,7 +1974,7 @@ bool8 LavaridgeGym1FWarpEffect_4(struct Task *task, struct ObjectEvent *objectEv return FALSE; } -bool8 LavaridgeGym1FWarpEffect_5(struct Task *task, struct ObjectEvent *objectEvent, struct Sprite *sprite) +bool8 LavaridgeGym1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (!gPaletteFade.active && BGMusicStopped() == TRUE) { @@ -1994,7 +1996,7 @@ u8 FldEff_PopOutOfAsh(void) return spriteId; } -void SpriteCB_PopOutOfAsh(struct Sprite *sprite) +void SpriteCB_PopOutOfAsh(struct Sprite * sprite) { if (sprite->animEnded) { @@ -2240,7 +2242,7 @@ void TeleportInFieldEffectTask1(struct Task * task); void TeleportInFieldEffectTask2(struct Task * task); void TeleportInFieldEffectTask3(struct Task * task); -void (*const sTeleportEffectFuncs[])(struct Task *) = { +void (*const sTeleportEffectFuncs[])(struct Task * ) = { TeleportFieldEffectTask1, TeleportFieldEffectTask2, TeleportFieldEffectTask3, @@ -2257,7 +2259,7 @@ void Task_DoTeleportFieldEffect(u8 taskId) sTeleportEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void TeleportFieldEffectTask1(struct Task *task) +void TeleportFieldEffectTask1(struct Task * task) { ScriptContext2_Enable(); FreezeObjectEvents(); @@ -2266,7 +2268,7 @@ void TeleportFieldEffectTask1(struct Task *task) task->data[0]++; } -void TeleportFieldEffectTask2(struct Task *task) +void TeleportFieldEffectTask2(struct Task * task) { u8 spinDirections[5] = { [DIR_NONE] = DIR_SOUTH, @@ -2275,7 +2277,7 @@ void TeleportFieldEffectTask2(struct Task *task) [DIR_NORTH] = DIR_EAST, [DIR_EAST] = DIR_SOUTH }; - struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; if (task->data[1] == 0 || (--task->data[1]) == 0) { ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]); @@ -2292,11 +2294,11 @@ void TeleportFieldEffectTask2(struct Task *task) } } -void TeleportFieldEffectTask3(struct Task *task) +void TeleportFieldEffectTask3(struct Task * task) { u8 spinDirections[5] = {DIR_SOUTH, DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH}; - struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; - struct Sprite *sprite = &gSprites[gPlayerAvatar.spriteId]; + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + struct Sprite * sprite = &gSprites[gPlayerAvatar.spriteId]; if ((--task->data[1]) <= 0) { task->data[1] = 4; @@ -2320,7 +2322,7 @@ void TeleportFieldEffectTask3(struct Task *task) } } -void TeleportFieldEffectTask4(struct Task *task) +void TeleportFieldEffectTask4(struct Task * task) { if (!gPaletteFade.active) { @@ -2335,7 +2337,7 @@ void TeleportFieldEffectTask4(struct Task *task) } } -void (*const sTeleportInEffectFuncs[])(struct Task *) = { +void (*const sTeleportInEffectFuncs[])(struct Task * ) = { TeleportInFieldEffectTask1, TeleportInFieldEffectTask2, TeleportInFieldEffectTask3 @@ -2359,9 +2361,9 @@ void Task_DoTeleportInFieldEffect(u8 taskId) sTeleportInEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void TeleportInFieldEffectTask1(struct Task *task) +void TeleportInFieldEffectTask1(struct Task * task) { - struct Sprite *sprite; + struct Sprite * sprite; s16 centerToCornerVecY; if (IsWeatherNotFadingIn()) { @@ -2378,11 +2380,11 @@ void TeleportInFieldEffectTask1(struct Task *task) } } -void TeleportInFieldEffectTask2(struct Task *task) +void TeleportInFieldEffectTask2(struct Task * task) { u8 spinDirections[5] = {1, 3, 4, 2, 1}; - struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; - struct Sprite *sprite = &gSprites[gPlayerAvatar.spriteId]; + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + struct Sprite * sprite = &gSprites[gPlayerAvatar.spriteId]; if ((sprite->pos2.y += task->data[1]) >= -8) { if (task->data[13] == 0) @@ -2417,10 +2419,10 @@ void TeleportInFieldEffectTask2(struct Task *task) } } -void TeleportInFieldEffectTask3(struct Task *task) +void TeleportInFieldEffectTask3(struct Task * task) { u8 spinDirections[5] = {1, 3, 4, 2, 1}; - struct ObjectEvent *objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; if ((--task->data[1]) == 0) { ObjectEventTurn(objectEvent, spinDirections[objectEvent->facingDirection]); @@ -2434,3 +2436,432 @@ void TeleportInFieldEffectTask3(struct Task *task) } } } + +void Task_ShowMon_Outdoors(u8 taskId); +void ShowMonEffect_Outdoors_1(struct Task * task); +void ShowMonEffect_Outdoors_2(struct Task * task); +void ShowMonEffect_Outdoors_3(struct Task * task); +void ShowMonEffect_Outdoors_4(struct Task * task); +void ShowMonEffect_Outdoors_5(struct Task * task); +void ShowMonEffect_Outdoors_6(struct Task * task); +void ShowMonEffect_Outdoors_7(struct Task * task); +void VBlankCB_ShowMonEffect_Outdoors(void); +void LoadFieldMoveStreaksTilemapToVram(u16 screenbase); +void Task_ShowMon_Indoors(u8 taskId); +void ShowMonEffect_Indoors_1(struct Task * task); +void ShowMonEffect_Indoors_2(struct Task * task); +void ShowMonEffect_Indoors_3(struct Task * task); +void ShowMonEffect_Indoors_4(struct Task * task); +void ShowMonEffect_Indoors_5(struct Task * task); +void ShowMonEffect_Indoors_6(struct Task * task); +void ShowMonEffect_Indoors_7(struct Task * task); +void VBlankCB_ShowMonEffect_Indoors(void); +void sub_8086728(struct Task * task); +bool8 sub_8086738(struct Task * task); +bool8 sub_80867F0(struct Task * task); +u8 sub_8086860(u32 species, u32 otId, u32 personality); +void sub_80868C0(struct Sprite * sprite); +void sub_8086904(struct Sprite * sprite); +void sub_8086920(struct Sprite * sprite); + +void (*const sShowMonOutdoorsEffectFuncs[])(struct Task * task) = { + ShowMonEffect_Outdoors_1, + ShowMonEffect_Outdoors_2, + ShowMonEffect_Outdoors_3, + ShowMonEffect_Outdoors_4, + ShowMonEffect_Outdoors_5, + ShowMonEffect_Outdoors_6, + ShowMonEffect_Outdoors_7 +}; + +u32 FldEff_FieldMoveShowMon(void) +{ + u8 taskId; + if (IsMapTypeOutdoors(GetCurrentMapType()) == TRUE) + taskId = CreateTask(Task_ShowMon_Outdoors, 0xFF); + else + taskId = CreateTask(Task_ShowMon_Indoors, 0xFF); + gTasks[taskId].data[15] = sub_8086860(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); + return 0; +} + +u32 FldEff_FieldMoveShowMonInit(void) +{ + u32 r6 = gFieldEffectArguments[0] & 0x80000000; + u8 partyIdx = gFieldEffectArguments[0]; + gFieldEffectArguments[0] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_SPECIES); + gFieldEffectArguments[1] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_OT_ID); + gFieldEffectArguments[2] = GetMonData(&gPlayerParty[partyIdx], MON_DATA_PERSONALITY); + gFieldEffectArguments[0] |= r6; + FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON); + FieldEffectActiveListRemove(FLDEFF_FIELD_MOVE_SHOW_MON_INIT); + return 0; +} + +void Task_ShowMon_Outdoors(u8 taskId) +{ + sShowMonOutdoorsEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void ShowMonEffect_Outdoors_1(struct Task * task) +{ + task->data[11] = GetGpuReg(REG_OFFSET_WININ); + task->data[12] = GetGpuReg(REG_OFFSET_WINOUT); + StoreWordInTwoHalfwords((u16*)&task->data[13], (u32)gMain.vblankCallback); + task->data[1] = 0xf0f1; + task->data[2] = 0x5051; + task->data[3] = 0x3f; + task->data[4] = 0x3e; + SetGpuReg(REG_OFFSET_WIN0H, task->data[1]); + SetGpuReg(REG_OFFSET_WIN0V, task->data[2]); + SetGpuReg(REG_OFFSET_WININ, task->data[3]); + SetGpuReg(REG_OFFSET_WINOUT, task->data[4]); + SetVBlankCallback(VBlankCB_ShowMonEffect_Outdoors); + task->data[0]++; +} + +void ShowMonEffect_Outdoors_2(struct Task * task) +{ + u16 charbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 2) << 14); + u16 screenbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11); + CpuCopy16(gFieldMoveStreaksTiles, (void *)(VRAM + charbase), 0x200); + CpuFill32(0, (void *)(VRAM + screenbase), 0x800); + LoadPalette(gFieldMoveStreaksPalette, 0xf0, 0x20); + LoadFieldMoveStreaksTilemapToVram(screenbase); + task->data[0]++; +} + +void ShowMonEffect_Outdoors_3(struct Task * task) +{ + s16 v0; + s16 v2; + s16 v3; + task->data[5] -= 16; + v0 = ((u16)task->data[1] >> 8); + v2 = ((u16)task->data[2] >> 8); + v3 = ((u16)task->data[2] & 0xff); + v0 -= 16; + v2 -= 2; + v3 += 2; + if (v0 < 0) + { + v0 = 0; + } + if (v2 < 0x28) + { + v2 = 0x28; + } + if (v3 > 0x78) + { + v3 = 0x78; + } + task->data[1] = (v0 << 8) | (task->data[1] & 0xff); + task->data[2] = (v2 << 8) | v3; + if (v0 == 0 && v2 == 0x28 && v3 == 0x78) + { + gSprites[task->data[15]].callback = sub_80868C0; + task->data[0]++; + } +} + +void ShowMonEffect_Outdoors_4(struct Task * task) +{ + task->data[5] -= 16; + if (gSprites[task->data[15]].data[7]) + { + task->data[0]++; + } +} + +void ShowMonEffect_Outdoors_5(struct Task * task) +{ + s16 v2; + s16 v3; + task->data[5] -= 16; + v2 = (task->data[2] >> 8); + v3 = (task->data[2] & 0xff); + v2 += 6; + v3 -= 6; + if (v2 > 0x50) + { + v2 = 0x50; + } + if (v3 < 0x51) + { + v3 = 0x51; + } + task->data[2] = (v2 << 8) | v3; + if (v2 == 0x50 && v3 == 0x51) + { + task->data[0]++; + } +} + +void ShowMonEffect_Outdoors_6(struct Task * task) +{ + u16 bg0cnt = (GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11; + CpuFill32(0, (void *)VRAM + bg0cnt, 0x800); + task->data[1] = 0xf1; + task->data[2] = 0xa1; + task->data[3] = task->data[11]; + task->data[4] = task->data[12]; + task->data[0]++; +} + +void ShowMonEffect_Outdoors_7(struct Task * task) +{ + IntrCallback callback; + LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&callback); + SetVBlankCallback(callback); + ChangeBgX(0, 0, 0); + ChangeBgY(0, 0, 0); + Menu_LoadStdPal(); + FreeResourcesAndDestroySprite(&gSprites[task->data[15]], task->data[15]); + FieldEffectActiveListRemove(FLDEFF_FIELD_MOVE_SHOW_MON); + DestroyTask(FindTaskIdByFunc(Task_ShowMon_Outdoors)); +} + +void VBlankCB_ShowMonEffect_Outdoors(void) +{ + IntrCallback callback; + struct Task * task = &gTasks[FindTaskIdByFunc(Task_ShowMon_Outdoors)]; + LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&callback); + callback(); + SetGpuReg(REG_OFFSET_WIN0H, task->data[1]); + SetGpuReg(REG_OFFSET_WIN0V, task->data[2]); + SetGpuReg(REG_OFFSET_WININ, task->data[3]); + SetGpuReg(REG_OFFSET_WINOUT, task->data[4]); + SetGpuReg(REG_OFFSET_BG0HOFS, task->data[5]); + SetGpuReg(REG_OFFSET_BG0VOFS, task->data[6]); +} + +void LoadFieldMoveStreaksTilemapToVram(u16 screenbase) +{ + u16 i; + u16 *dest; + dest = (u16 *)(VRAM + (10 * 32) + screenbase); + for (i = 0; i < (10 * 32); i++, dest++) + { + *dest = gFieldMoveStreaksTilemap[i] | METATILE_ELEVATION_MASK; + } +} + +void (*const sShowMonIndoorsEffectFuncs[])(struct Task * ) = { + ShowMonEffect_Indoors_1, + ShowMonEffect_Indoors_2, + ShowMonEffect_Indoors_3, + ShowMonEffect_Indoors_4, + ShowMonEffect_Indoors_5, + ShowMonEffect_Indoors_6, + ShowMonEffect_Indoors_7 +}; + +void Task_ShowMon_Indoors(u8 taskId) +{ + sShowMonIndoorsEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void ShowMonEffect_Indoors_1(struct Task * task) +{ + SetGpuReg(REG_OFFSET_BG0HOFS, task->data[1]); + SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]); + StoreWordInTwoHalfwords((u16 *)&task->data[13], (u32)gMain.vblankCallback); + SetVBlankCallback(VBlankCB_ShowMonEffect_Indoors); + task->data[0]++; +} + +void ShowMonEffect_Indoors_2(struct Task * task) +{ + u16 charbase; + u16 screenbase; + charbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 2) << 14); + screenbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11); + task->data[12] = screenbase; + CpuCopy16(gDarknessFieldMoveStreaksTiles, (void *)(VRAM + charbase), 0x80); + CpuFill32(0, (void *)(VRAM + screenbase), 0x800); + LoadPalette(gDarknessFieldMoveStreaksPalette, 0xf0, 0x20); + task->data[0]++; +} + +void ShowMonEffect_Indoors_3(struct Task * task) +{ + if (sub_8086738(task)) + { + task->data[5] = GetGpuReg(REG_OFFSET_WININ); + SetGpuReg(REG_OFFSET_WININ, (task->data[5] & 0xFF) | 0x1100); + SetGpuReg(REG_OFFSET_WIN1H, 0x00f0); + SetGpuReg(REG_OFFSET_WIN1V, 0x2878); + gSprites[task->data[15]].callback = sub_80868C0; + task->data[0]++; + } + sub_8086728(task); +} + +void ShowMonEffect_Indoors_4(struct Task * task) +{ + sub_8086728(task); + if (gSprites[task->data[15]].data[7]) + { + task->data[0]++; + } +} + +void ShowMonEffect_Indoors_5(struct Task * task) +{ + sub_8086728(task); + task->data[3] = task->data[1] & 7; + task->data[4] = 0; + SetGpuReg(REG_OFFSET_WIN1H, 0xffff); + SetGpuReg(REG_OFFSET_WIN1V, 0xffff); + SetGpuReg(REG_OFFSET_WININ, task->data[5]); + task->data[0]++; +} + +void ShowMonEffect_Indoors_6(struct Task * task) +{ + sub_8086728(task); + if (sub_80867F0(task)) + { + task->data[0]++; + } +} + +void ShowMonEffect_Indoors_7(struct Task * task) +{ + IntrCallback intrCallback; + u16 charbase; + charbase = (GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11; + CpuFill32(0, (void *)VRAM + charbase, 0x800); + LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&intrCallback); + SetVBlankCallback(intrCallback); + ChangeBgX(0, 0, 0); + ChangeBgY(0, 0, 0); + Menu_LoadStdPal(); + FreeResourcesAndDestroySprite(&gSprites[task->data[15]], task->data[15]); + FieldEffectActiveListRemove(FLDEFF_FIELD_MOVE_SHOW_MON); + DestroyTask(FindTaskIdByFunc(Task_ShowMon_Indoors)); +} + +void VBlankCB_ShowMonEffect_Indoors(void) +{ + IntrCallback intrCallback; + struct Task * task; + task = &gTasks[FindTaskIdByFunc(Task_ShowMon_Indoors)]; + LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&intrCallback); + intrCallback(); + SetGpuReg(REG_OFFSET_BG0HOFS, task->data[1]); + SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]); +} + +void sub_8086728(struct Task * task) +{ + task->data[1] -= 16; + task->data[3] += 16; +} + +bool8 sub_8086738(struct Task * task) +{ + u16 i; + u16 srcOffs; + u16 dstOffs; + u16 *dest; + if (task->data[4] >= 32) + { + return TRUE; + } + dstOffs = (task->data[3] >> 3) & 0x1f; + if (dstOffs >= task->data[4]) + { + dstOffs = (32 - dstOffs) & 0x1f; + srcOffs = (32 - task->data[4]) & 0x1f; + dest = (u16 *)(VRAM + 0x140 + (u16)task->data[12]); + for (i = 0; i < 10; i++) + { + dest[dstOffs + i * 32] = gDarknessFieldMoveStreaksTilemap[srcOffs + i * 32]; + dest[dstOffs + i * 32] |= 0xf000; + + dest[((dstOffs + 1) & 0x1f) + i * 32] = gDarknessFieldMoveStreaksTilemap[((srcOffs + 1) & 0x1f) + i * 32] | 0xf000; + dest[((dstOffs + 1) & 0x1f) + i * 32] |= 0xf000; + } + task->data[4] += 2; + } + return FALSE; +} + +bool8 sub_80867F0(struct Task * task) +{ + u16 i; + u16 dstOffs; + u16 *dest; + if (task->data[4] >= 32) + { + return TRUE; + } + dstOffs = task->data[3] >> 3; + if (dstOffs >= task->data[4]) + { + dstOffs = (task->data[1] >> 3) & 0x1f; + dest = (u16 *)(VRAM + 0x140 + (u16)task->data[12]); + for (i = 0; i < 10; i++) + { + dest[dstOffs + i * 32] = 0xf000; + dest[((dstOffs + 1) & 0x1f) + i * 32] = 0xf000; + } + task->data[4] += 2; + } + return FALSE; +} + +u8 sub_8086860(u32 species, u32 otId, u32 personality) +{ + bool16 playCry; + u8 monSprite; + struct Sprite * sprite; + playCry = (species & 0x80000000) >> 16; + species &= 0x7fffffff; + monSprite = CreateMonSprite_FieldMove(species, otId, personality, 0x140, 0x50, 0); + sprite = &gSprites[monSprite]; + sprite->callback = SpriteCallbackDummy; + sprite->oam.priority = 0; + sprite->data[0] = species; + sprite->data[6] = playCry; + return monSprite; +} + +void sub_80868C0(struct Sprite * sprite) +{ + if ((sprite->pos1.x -= 20) <= 0x78) + { + sprite->pos1.x = 0x78; + sprite->data[1] = 30; + sprite->callback = sub_8086904; + if (sprite->data[6]) + { + PlayCry2(sprite->data[0], 0, 0x7d, 0xa); + } + else + { + PlayCry1(sprite->data[0], 0); + } + } +} + +void sub_8086904(struct Sprite * sprite) +{ + if ((--sprite->data[1]) == 0) + { + sprite->callback = sub_8086920; + } +} + +void sub_8086920(struct Sprite * sprite) +{ + if (sprite->pos1.x < -0x40) + { + sprite->data[7] = 1; + } + else + { + sprite->pos1.x -= 20; + } +} -- cgit v1.2.3 From 80e5031619f388ba3274ca573e58451cb443d54b Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 15:29:16 -0500 Subject: Use Surf field effect --- src/field_effect.c | 102 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 102 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index ecdc834ae..9695e4900 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -7,6 +7,7 @@ #include "field_camera.h" #include "field_control_avatar.h" #include "field_effect.h" +#include "field_effect_helpers.h" #include "field_effect_scripts.h" #include "field_fadetransition.h" #include "field_player_avatar.h" @@ -24,6 +25,7 @@ #include "trainer_pokemon_sprites.h" #include "trig.h" #include "util.h" +#include "constants/event_object_movement.h" #include "constants/metatile_behaviors.h" #include "constants/songs.h" @@ -2865,3 +2867,103 @@ void sub_8086920(struct Sprite * sprite) sprite->pos1.x -= 20; } } + +void Task_FldEffUseSurf(u8 taskId); +void UseSurfEffect_1(struct Task * task); +void UseSurfEffect_2(struct Task * task); +void UseSurfEffect_3(struct Task * task); +void UseSurfEffect_4(struct Task * task); +void UseSurfEffect_5(struct Task * task); + +void (*const sUseSurfEffectFuncs[])(struct Task * ) = { + UseSurfEffect_1, + UseSurfEffect_2, + UseSurfEffect_3, + UseSurfEffect_4, + UseSurfEffect_5, +}; + +u8 FldEff_UseSurf(void) +{ + u8 taskId = CreateTask(Task_FldEffUseSurf, 0xff); + gTasks[taskId].data[15] = gFieldEffectArguments[0]; + sav1_reset_battle_music_maybe(); + if (sub_8056124(MUS_NAMINORI)) + Overworld_ChangeMusicTo(MUS_NAMINORI); + return FALSE; +} + +void Task_FldEffUseSurf(u8 taskId) +{ + sUseSurfEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void UseSurfEffect_1(struct Task * task) +{ + ScriptContext2_Enable(); + FreezeObjectEvents(); + gPlayerAvatar.preventStep = TRUE; + SetPlayerAvatarStateMask(8); + PlayerGetDestCoords(&task->data[1], &task->data[2]); + MoveCoords(gObjectEvents[gPlayerAvatar.objectEventId].placeholder18, &task->data[1], &task->data[2]); + task->data[0]++; +} + +void UseSurfEffect_2(struct Task * task) +{ + struct ObjectEvent * objectEvent; + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + sub_805CB70(); + ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION); + task->data[0]++; + } +} + +void UseSurfEffect_3(struct Task * task) +{ + struct ObjectEvent * objectEvent; + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (ObjectEventCheckHeldMovementStatus(objectEvent)) + { + gFieldEffectArguments[0] = task->data[15] | 0x80000000; + FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT); + task->data[0]++; + } +} + +void UseSurfEffect_4(struct Task * task) +{ + struct ObjectEvent * objectEvent; + if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON)) + { + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2)); + ObjectEventClearHeldMovementIfFinished(objectEvent); + ObjectEventSetHeldMovement(objectEvent, sub_80641C0(objectEvent->placeholder18)); + gFieldEffectArguments[0] = task->data[1]; + gFieldEffectArguments[1] = task->data[2]; + gFieldEffectArguments[2] = gPlayerAvatar.objectEventId; + objectEvent->mapobj_unk_1A = FieldEffectStart(FLDEFF_SURF_BLOB); + task->data[0]++; + } +} + +void UseSurfEffect_5(struct Task * task) +{ + struct ObjectEvent * objectEvent; + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + gPlayerAvatar.preventStep = FALSE; + gPlayerAvatar.flags &= 0xdf; + ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(objectEvent->placeholder18)); + sub_80DC44C(objectEvent->mapobj_unk_1A, 1); + UnfreezeObjectEvents(); + ScriptContext2_Disable(); + FieldEffectActiveListRemove(FLDEFF_USE_SURF); + DestroyTask(FindTaskIdByFunc(Task_FldEffUseSurf)); + HelpSystem_SetSomeVariable2(22); + } +} -- cgit v1.2.3 From f8251866551143e2febe55fe47e92f7c826696b3 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 15:55:12 -0500 Subject: Use VS Seeker field effect --- src/field_effect.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 9695e4900..3b710167d 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -2967,3 +2967,75 @@ void UseSurfEffect_5(struct Task * task) HelpSystem_SetSomeVariable2(22); } } + +void Task_FldEffUseVsSeeker(u8 taskId); +void UseVsSeekerEffect_1(struct Task * task); +void UseVsSeekerEffect_2(struct Task * task); +void UseVsSeekerEffect_3(struct Task * task); +void UseVsSeekerEffect_4(struct Task * task); + +void (*const sUseVsSeekerEffectFuncs[])(struct Task * task) = { + UseVsSeekerEffect_1, + UseVsSeekerEffect_2, + UseVsSeekerEffect_3, + UseVsSeekerEffect_4 +}; + +u32 FldEff_UseVsSeeker(void) +{ + if (gQuestLogState == QL_STATE_1) + sub_811278C(8, 89); + CreateTask(Task_FldEffUseVsSeeker, 0xFF); + return 0; +} + +void Task_FldEffUseVsSeeker(u8 taskId) +{ + sUseVsSeekerEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void UseVsSeekerEffect_1(struct Task * task) +{ + ScriptContext2_Enable(); + FreezeObjectEvents(); + gPlayerAvatar.preventStep = TRUE; + task->data[0]++; +} + +void UseVsSeekerEffect_2(struct Task * task) +{ + struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (!ObjectEventIsMovementOverridden(playerObj) || ObjectEventClearHeldMovementIfFinished(playerObj)) + { + sub_805CBE8(); + ObjectEventSetHeldMovement(playerObj, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION); + task->data[0]++; + } +} + +void UseVsSeekerEffect_3(struct Task * task) +{ + struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (ObjectEventClearHeldMovementIfFinished(playerObj)) + { + if (gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_ACRO_BIKE | PLAYER_AVATAR_FLAG_MACH_BIKE)) + ObjectEventSetGraphicsId(playerObj, GetPlayerAvatarGraphicsIdByStateId(1)); + else if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING) + ObjectEventSetGraphicsId(playerObj, GetPlayerAvatarGraphicsIdByStateId(2)); + else + ObjectEventSetGraphicsId(playerObj, GetPlayerAvatarGraphicsIdByStateId(0)); + ObjectEventForceSetSpecialAnim(playerObj, GetFaceDirectionMovementAction(playerObj->facingDirection)); + task->data[0]++; + } +} + +void UseVsSeekerEffect_4(struct Task * task) +{ + struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (ObjectEventClearHeldMovementIfFinished(playerObj)) + { + gPlayerAvatar.preventStep = FALSE; + FieldEffectActiveListRemove(FLDEFF_USE_VS_SEEKER); + DestroyTask(FindTaskIdByFunc(Task_FldEffUseVsSeeker)); + } +} -- cgit v1.2.3 From fb064f17ba63a79df09901c874b03665f4bf11e8 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 28 Feb 2020 17:10:06 -0500 Subject: Fly field effect --- src/field_effect.c | 585 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 585 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 3b710167d..81b572893 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -3039,3 +3039,588 @@ void UseVsSeekerEffect_4(struct Task * task) DestroyTask(FindTaskIdByFunc(Task_FldEffUseVsSeeker)); } } + +void sub_8086D94(struct Sprite * sprite); + +u8 FldEff_NpcFlyOut(void) +{ + u8 spriteId = CreateSprite(gFieldEffectObjectTemplatePointers[26], 0x78, 0, 1); + struct Sprite * sprite = &gSprites[spriteId]; + + sprite->oam.paletteNum = 0; + sprite->oam.priority = 1; + sprite->callback = sub_8086D94; + sprite->data[1] = gFieldEffectArguments[0]; + PlaySE(SE_W019); + return spriteId; +} + +void sub_8086D94(struct Sprite * sprite) +{ + struct Sprite * npcSprite; + + sprite->pos2.x = Cos(sprite->data[2], 0x8c); + sprite->pos2.y = Sin(sprite->data[2], 0x48); + sprite->data[2] = (sprite->data[2] + 4) & 0xff; + if (sprite->data[0]) + { + npcSprite = &gSprites[sprite->data[1]]; + npcSprite->coordOffsetEnabled = 0; + npcSprite->pos1.x = sprite->pos1.x + sprite->pos2.x; + npcSprite->pos1.y = sprite->pos1.y + sprite->pos2.y - 8; + npcSprite->pos2.x = 0; + npcSprite->pos2.y = 0; + } + if (sprite->data[2] >= 0x80) + { + FieldEffectStop(sprite, FLDEFF_NPCFLY_OUT); + } +} + +void Task_UseFly(u8 taskId); +void UseFlyEffect_1(struct Task * task); +void UseFlyEffect_2(struct Task * task); +void UseFlyEffect_3(struct Task * task); +void UseFlyEffect_4(struct Task * task); +void UseFlyEffect_5(struct Task * task); +void UseFlyEffect_6(struct Task * task); +void UseFlyEffect_7(struct Task * task); +void UseFlyEffect_8(struct Task * task); +void UseFlyEffect_9(struct Task * task); +u8 sub_8087168(void); +bool8 sub_80871AC(u8 flyBlobSpriteId); +void sub_80871C8(u8 flyBlobSpriteId); +void sub_8087204(u8 flyBlobSpriteId, u8 playerSpriteId); +void sub_8087220(struct Sprite * sprite); +void sub_80872F0(struct Sprite * sprite); +void sub_80877FC(struct Sprite * sprite, u8 affineAnimId); +void sub_8087828(struct Sprite * sprite); + +void (*const sUseFlyEffectFuncs[])(struct Task * ) = { + UseFlyEffect_1, + UseFlyEffect_2, + UseFlyEffect_3, + UseFlyEffect_4, + UseFlyEffect_5, + UseFlyEffect_6, + UseFlyEffect_7, + UseFlyEffect_8, + UseFlyEffect_9 +}; + +u8 FldEff_UseFly(void) +{ + u8 taskId = CreateTask(Task_UseFly, 0xfe); + gTasks[taskId].data[1] = gFieldEffectArguments[0]; + return 0; +} + +void Task_UseFly(u8 taskId) +{ + sUseFlyEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void UseFlyEffect_1(struct Task * task) +{ + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + task->data[15] = gPlayerAvatar.flags; + gPlayerAvatar.preventStep = TRUE; + SetPlayerAvatarStateMask(1); + sub_805CB70(); + ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION); + task->data[0]++; + } +} + +void UseFlyEffect_2(struct Task * task) +{ + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + task->data[0]++; + gFieldEffectArguments[0] = task->data[1]; + FieldEffectStart(FLDEFF_FIELD_MOVE_SHOW_MON_INIT); + } +} + +void UseFlyEffect_3(struct Task * task) +{ + if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON)) + { + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (task->data[15] & 0x08) + { + sub_80DC44C(objectEvent->mapobj_unk_1A, 2); + sub_80DC478(objectEvent->mapobj_unk_1A, 0); + } + task->data[1] = sub_8087168(); + task->data[0]++; + } +} + +void UseFlyEffect_4(struct Task * task) +{ + if (sub_80871AC(task->data[1])) + { + task->data[0]++; + task->data[2] = 16; + SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_ON_FOOT); + ObjectEventSetHeldMovement(&gObjectEvents[gPlayerAvatar.objectEventId], MOVEMENT_ACTION_FACE_LEFT); + } +} + +void UseFlyEffect_5(struct Task * task) +{ + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if ((task->data[2] == 0 || (--task->data[2]) == 0) && ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + task->data[0]++; + PlaySE(SE_W019); + sub_80871C8(task->data[1]); + } +} + +void UseFlyEffect_6(struct Task * task) +{ + if ((++task->data[2]) >= 8) + { + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2)); + StartSpriteAnim(&gSprites[objectEvent->spriteId], 0x16); + objectEvent->inanimate = 1; + ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_JUMP_IN_PLACE_LEFT); + task->data[0]++; + task->data[2] = 0; + } +} + +void UseFlyEffect_7(struct Task * task) +{ + if ((++task->data[2]) >= 10) + { + struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + ObjectEventClearAnimIfSpecialAnimActive(objectEvent); + objectEvent->inanimate = 0; + objectEvent->hasShadow = 0; + sub_8087204(task->data[1], objectEvent->spriteId); + StartSpriteAnim(&gSprites[task->data[1]], gSaveBlock2Ptr->playerGender * 2 + 1); + sub_80877FC(&gSprites[task->data[1]], 0); + gSprites[task->data[1]].callback = sub_8087828; + CameraObjectReset2(); + task->data[0]++; + } +} + +void UseFlyEffect_8(struct Task * task) +{ + if (sub_80871AC(task->data[1])) + { + WarpFadeOutScreen(); + task->data[0]++; + } +} + +void UseFlyEffect_9(struct Task * task) +{ + if (!gPaletteFade.active) + { + FieldEffectActiveListRemove(FLDEFF_USE_FLY); + DestroyTask(FindTaskIdByFunc(Task_UseFly)); + } +} + +u8 sub_8087168(void) +{ + u8 spriteId; + struct Sprite * sprite; + spriteId = CreateSprite(gFieldEffectObjectTemplatePointers[26], 0xff, 0xb4, 0x1); + sprite = &gSprites[spriteId]; + sprite->oam.paletteNum = 0; + sprite->oam.priority = 1; + sprite->callback = sub_8087220; + return spriteId; +} + +u8 sub_80871AC(u8 spriteId) +{ + return gSprites[spriteId].data[7]; +} + +void sub_80871C8(u8 spriteId) +{ + struct Sprite * sprite; + sprite = &gSprites[spriteId]; + sprite->callback = sub_80872F0; + sprite->pos1.x = 0x78; + sprite->pos1.y = 0x00; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + memset(&sprite->data[0], 0, 8 * sizeof(u16) /* zero all data cells */); + sprite->data[6] = 0x40; +} + +void sub_8087204(u8 a0, u8 a1) +{ + gSprites[a0].data[6] = a1; +} + +const union AffineAnimCmd gUnknown_83CC19C[] = { + AFFINEANIMCMD_FRAME( 8, 8, 226, 0), + AFFINEANIMCMD_FRAME(28, 28, 0, 30), + AFFINEANIMCMD_END +}; + +const union AffineAnimCmd gUnknown_83CC1B4[] = { + AFFINEANIMCMD_FRAME(256, 256, 64, 0), + AFFINEANIMCMD_FRAME(-10, -10, 0, 22), + AFFINEANIMCMD_END +}; + +const union AffineAnimCmd *const gUnknown_83CC1CC[] = { + gUnknown_83CC19C, + gUnknown_83CC1B4 +}; + +void sub_8087220(struct Sprite * sprite) +{ + if (sprite->data[7] == 0) + { + if (sprite->data[0] == 0) + { + sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; + sprite->affineAnims = gUnknown_83CC1CC; + InitSpriteAffineAnim(sprite); + StartSpriteAffineAnim(sprite, 0); + if (gSaveBlock2Ptr->playerGender == MALE) + sprite->pos1.x = 0x80; + else + sprite->pos1.x = 0x76; + sprite->pos1.y = -0x30; + sprite->data[0]++; + sprite->data[1] = 0x40; + sprite->data[2] = 0x100; + } + sprite->data[1] += (sprite->data[2] >> 8); + sprite->pos2.x = Cos(sprite->data[1], 0x78); + sprite->pos2.y = Sin(sprite->data[1], 0x78); + if (sprite->data[2] < 0x800) + { + sprite->data[2] += 0x60; + } + if (sprite->data[1] > 0x81) + { + sprite->data[7]++; + sprite->oam.affineMode = ST_OAM_AFFINE_OFF; + FreeOamMatrix(sprite->oam.matrixNum); + CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, ST_OAM_AFFINE_OFF); + } + } +} + +void sub_80872F0(struct Sprite * sprite) +{ + sprite->pos2.x = Cos(sprite->data[2], 0x8c); + sprite->pos2.y = Sin(sprite->data[2], 0x48); + sprite->data[2] = (sprite->data[2] + 4) & 0xff; + if (sprite->data[6] != MAX_SPRITES) + { + struct Sprite * sprite1 = &gSprites[sprite->data[6]]; + sprite1->coordOffsetEnabled = 0; + sprite1->pos1.x = sprite->pos1.x + sprite->pos2.x; + sprite1->pos1.y = sprite->pos1.y + sprite->pos2.y - 8; + sprite1->pos2.x = 0; + sprite1->pos2.y = 0; + } + if (sprite->data[2] >= 0x80) + { + sprite->data[7] = 1; + } +} + +void sub_8087364(struct Sprite * sprite) +{ + if (sprite->data[7] == 0) + { + if (sprite->data[0] == 0) + { + sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; + sprite->affineAnims = gUnknown_83CC1CC; + InitSpriteAffineAnim(sprite); + StartSpriteAffineAnim(sprite, 1); + if (gSaveBlock2Ptr->playerGender == MALE) + sprite->pos1.x = 0x70; + else + sprite->pos1.x = 0x64; + sprite->pos1.y = -0x20; + sprite->data[0]++; + sprite->data[1] = 0xf0; + sprite->data[2] = 0x800; + sprite->data[4] = 0x80; + } + sprite->data[1] += sprite->data[2] >> 8; + sprite->data[3] += sprite->data[2] >> 8; + sprite->data[1] &= 0xff; + sprite->pos2.x = Cos(sprite->data[1], 0x20); + sprite->pos2.y = Sin(sprite->data[1], 0x78); + if (sprite->data[2] > 0x100) + { + sprite->data[2] -= sprite->data[4]; + } + if (sprite->data[4] < 0x100) + { + sprite->data[4] += 24; + } + if (sprite->data[2] < 0x100) + { + sprite->data[2] = 0x100; + } + if (sprite->data[3] >= 60) + { + sprite->data[7]++; + sprite->oam.affineMode = ST_OAM_AFFINE_OFF; + FreeOamMatrix(sprite->oam.matrixNum); + sprite->invisible = TRUE; + } + } +} + +void sub_8087458(u8 spriteId) +{ + sub_80871C8(spriteId); + gSprites[spriteId].callback = sub_8087364; +} + +void Task_FldEffFlyIn(u8 taskId); +void FlyInEffect_1(struct Task * task); +void FlyInEffect_2(struct Task * task); +void FlyInEffect_3(struct Task * task); +void FlyInEffect_4(struct Task * task); +void FlyInEffect_5(struct Task * task); +void FlyInEffect_6(struct Task * task); +void FlyInEffect_7(struct Task * task); +void sub_80878C0(struct Sprite * sprite); + +void (*const sFlyInEffectFuncs[])(struct Task * task) = { + FlyInEffect_1, + FlyInEffect_2, + FlyInEffect_3, + FlyInEffect_4, + FlyInEffect_5, + FlyInEffect_6, + FlyInEffect_7 +}; + +u32 FldEff_FlyIn(void) +{ + CreateTask(Task_FldEffFlyIn, 0xfe); + return 0; +} + +void Task_FldEffFlyIn(u8 taskId) +{ + sFlyInEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); +} + +void FlyInEffect_1(struct Task * task) +{ + struct ObjectEvent * objectEvent; + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent)) + { + task->data[0]++; + task->data[2] = 33; + task->data[15] = gPlayerAvatar.flags; + gPlayerAvatar.preventStep = TRUE; + SetPlayerAvatarStateMask(0x01); + if (task->data[15] & 0x08) + { + sub_80DC44C(objectEvent->mapobj_unk_1A, 0); + } + ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2)); + CameraObjectReset2(); + ObjectEventTurn(objectEvent, DIR_WEST); + StartSpriteAnim(&gSprites[objectEvent->spriteId], 0x16); + objectEvent->invisible = FALSE; + task->data[1] = sub_8087168(); + sub_80871C8(task->data[1]); + sub_8087204(task->data[1], objectEvent->spriteId); + StartSpriteAnim(&gSprites[task->data[1]], gSaveBlock2Ptr->playerGender * 2 + 2); + sub_80877FC(&gSprites[task->data[1]], 1); + gSprites[task->data[1]].callback = sub_8087828; + } +} + +void FlyInEffect_2(struct Task * task) +{ + struct ObjectEvent * objectEvent; + struct Sprite * sprite; + sub_80878C0(&gSprites[task->data[1]]); + if (task->data[2] == 0 || (--task->data[2]) == 0) + { + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + sprite = &gSprites[objectEvent->spriteId]; + sub_8087204(task->data[1], 0x40); + sprite->pos1.x += sprite->pos2.x; + sprite->pos1.y += sprite->pos2.y; + sprite->pos2.x = 0; + sprite->pos2.y = 0; + task->data[0]++; + task->data[2] = 0; + } +} + +void FlyInEffect_3(struct Task * task) +{ + s16 gUnknown_83CC1F0[18] = { + -2, + -4, + -5, + -6, + -7, + -8, + -8, + -8, + -7, + -7, + -6, + -5, + -3, + -2, + 0, + 2, + 4, + 8 + }; + struct Sprite * sprite = &gSprites[gPlayerAvatar.spriteId]; + sprite->pos2.y = gUnknown_83CC1F0[task->data[2]]; + if ((++task->data[2]) >= 18) + { + task->data[0]++; + } +} + +void FlyInEffect_4(struct Task * task) +{ + struct ObjectEvent * objectEvent; + struct Sprite * sprite; + if (sub_80871AC(task->data[1])) + { + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + sprite = &gSprites[objectEvent->spriteId]; + objectEvent->inanimate = 0; + sub_805F724(objectEvent, objectEvent->currentCoords.x, objectEvent->currentCoords.y); + sprite->pos2.x = 0; + sprite->pos2.y = 0; + sprite->coordOffsetEnabled = 1; + sub_805CB70(); + ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION); + task->data[0]++; + } +} + +void FlyInEffect_5(struct Task * task) +{ + if (ObjectEventClearHeldMovementIfFinished(&gObjectEvents[gPlayerAvatar.objectEventId])) + { + task->data[0]++; + sub_8087458(task->data[1]); + } +} + +void FlyInEffect_6(struct Task * task) +{ + if (sub_80871AC(task->data[1])) + { + DestroySprite(&gSprites[task->data[1]]); + task->data[0]++; + task->data[1] = 0x10; + } +} + +void FlyInEffect_7(struct Task * task) +{ + u8 state; + struct ObjectEvent * objectEvent; + if ((--task->data[1]) == 0) + { + objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; + state = 0; + if (task->data[15] & 0x08) + { + state = 2; + sub_80DC44C(objectEvent->mapobj_unk_1A, 1); + } + ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(state)); + ObjectEventTurn(objectEvent, DIR_SOUTH); + gPlayerAvatar.flags = task->data[15]; + gPlayerAvatar.preventStep = FALSE; + FieldEffectActiveListRemove(FLDEFF_FLY_IN); + DestroyTask(FindTaskIdByFunc(Task_FldEffFlyIn)); + } +} + +const union AffineAnimCmd gUnknown_83CC214[] = { + AFFINEANIMCMD_FRAME(24, 24, 0, 1), + AFFINEANIMCMD_JUMP(0) +}; + +const union AffineAnimCmd gUnknown_83CC224[] = { + AFFINEANIMCMD_FRAME(512, 512, 0, 1), + AFFINEANIMCMD_FRAME(-16, -16, 0, 1), + AFFINEANIMCMD_JUMP(1) +}; + +const union AffineAnimCmd *const gUnknown_83CC23C[] = { + gUnknown_83CC214, + gUnknown_83CC224 +}; + +void sub_80877FC(struct Sprite * sprite, u8 affineAnimId) +{ + sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; + sprite->affineAnims = gUnknown_83CC23C; + InitSpriteAffineAnim(sprite); + StartSpriteAffineAnim(sprite, affineAnimId); +} + +void sub_8087828(struct Sprite * sprite) +{ + struct Sprite * sprite2; + sprite->pos2.x = Cos(sprite->data[2], 0xB4); + sprite->pos2.y = Sin(sprite->data[2], 0x48); + sprite->data[2] += 2; + sprite->data[2] &= 0xFF; + if (sprite->data[6] != MAX_SPRITES) + { + sprite2 = &gSprites[sprite->data[6]]; + sprite2->coordOffsetEnabled = FALSE; + sprite2->pos1.x = sprite->pos1.x + sprite->pos2.x; + sprite2->pos1.y = sprite->pos1.y + sprite->pos2.y - 8; + sprite2->pos2.x = 0; + sprite2->pos2.y = 0; + } + if (sprite->data[2] >= 0x80) + { + sprite->data[7] = 1; + sprite->oam.affineMode = ST_OAM_AFFINE_OFF; + FreeOamMatrix(sprite->oam.matrixNum); + CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, ST_OAM_AFFINE_OFF); + } +} + +void sub_80878C0(struct Sprite * sprite) +{ + if (sprite->oam.affineMode != ST_OAM_AFFINE_OFF) + { + if (gOamMatrices[sprite->oam.matrixNum].a == 0x100 || gOamMatrices[sprite->oam.matrixNum].d == 0x100) + { + sprite->oam.affineMode = ST_OAM_AFFINE_OFF; + FreeOamMatrix(sprite->oam.matrixNum); + CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, ST_OAM_AFFINE_OFF); + StartSpriteAnim(sprite, 0); + sprite->callback = sub_80872F0; + } + } +} -- cgit v1.2.3 From a506860558e71be26b4c37e9ac67b431ff0674a0 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 2 Mar 2020 09:18:32 -0500 Subject: field effect 0x43 --- src/field_effect.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 81b572893..a38924549 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -3624,3 +3624,67 @@ void sub_80878C0(struct Sprite * sprite) } } } + +void Task_FldEffUnk43(u8 taskId); + +bool8 FldEff_Unk43(void) +{ + u8 taskId; + u8 objectEventIdBuffer; + s32 x; + s32 y; + struct ObjectEvent * objectEvent; + if (!TryGetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2], &objectEventIdBuffer)) + { + objectEvent = &gObjectEvents[objectEventIdBuffer]; + x = objectEvent->currentCoords.x - 7; + y = objectEvent->currentCoords.y - 7; + x = (gFieldEffectArguments[3] - x) * 16; + y = (gFieldEffectArguments[4] - y) * 16; + npc_coords_shift(objectEvent, gFieldEffectArguments[3] + 7, gFieldEffectArguments[4] + 7); + taskId = CreateTask(Task_FldEffUnk43, 0x50); + gTasks[taskId].data[1] = objectEvent->spriteId; + gTasks[taskId].data[2] = gSprites[objectEvent->spriteId].pos1.x + x; + gTasks[taskId].data[3] = gSprites[objectEvent->spriteId].pos1.y + y; + gTasks[taskId].data[8] = gFieldEffectArguments[5]; + gTasks[taskId].data[9] = objectEventIdBuffer; + } + return FALSE; +} + +void Task_FldEffUnk43(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + struct Sprite * sprite = &gSprites[data[1]]; + struct ObjectEvent * objectEvent; + switch (data[0]) + { + case 0: + data[4] = sprite->pos1.x << 4; + data[5] = sprite->pos1.y << 4; + data[6] = ((data[2] << 4) - data[4]) / data[8]; + data[7] = ((data[3] << 4) - data[5]) / data[8]; + data[0]++; + // fallthrough + case 1: + if (data[8] != 0) + { + data[8]--; + data[4] += data[6]; + data[5] += data[7]; + sprite->pos1.x = data[4] >> 4; + sprite->pos1.y = data[5] >> 4; + } + else + { + objectEvent = &gObjectEvents[data[9]]; + sprite->pos1.x = data[2]; + sprite->pos1.y = data[3]; + npc_coords_shift_still(objectEvent); + objectEvent->triggerGroundEffectsOnStop = TRUE; + FieldEffectActiveListRemove(FLDEFF_UNK_43); + DestroyTask(taskId); + } + break; + } +} -- cgit v1.2.3 From a7966b5047cde2c32d3222847b1a048b5aaef343 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 2 Mar 2020 09:47:33 -0500 Subject: Finish field_effect.c --- src/field_effect.c | 237 ++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 227 insertions(+), 10 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index a38924549..59c3677f9 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -67,7 +67,7 @@ const u16 gFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83 const u16 gDarknessFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp"); const u16 gDarknessFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal"); const u16 gDarknessFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin"); -const u16 gUnknown_83CBDB0[] = INCBIN_U16("graphics/field_effects/unk_83CBDB0.4bpp"); +const u16 sFldEffUnk44_Tiles[] = INCBIN_U16("graphics/field_effects/unk_83CBDB0.4bpp"); bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = { FieldEffectCmd_loadtiles, @@ -96,7 +96,7 @@ const struct OamData gNewGameOakOamAttributes = { .affineParam = 0 }; -const struct OamData gOamData_83CBE58 = { +const struct OamData sOamData_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, @@ -112,7 +112,7 @@ const struct OamData gOamData_83CBE58 = { .affineParam = 0 }; -const struct OamData gOamData_83CBE60 = { +const struct OamData sOamData_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, @@ -308,7 +308,7 @@ const union AnimCmd *const gUnknown_83CBF84[] = { const struct SpriteTemplate gUnknown_83CBF88 = { .tileTag = 65535, .paletteTag = 4103, - .oam = &gOamData_83CBE58, + .oam = &sOamData_8x8, .anims = gUnknown_83CBF54, .images = gUnknown_83CBEB4, .affineAnims = gDummySpriteAffineAnimTable, @@ -328,7 +328,7 @@ const struct SpriteTemplate gUnknown_83CBFA0 = { const struct SpriteTemplate gUnknown_83CBFB8 = { .tileTag = 65535, .paletteTag = 4112, - .oam = &gOamData_83CBE60, + .oam = &sOamData_16x16, .anims = gUnknown_83CBF84, .images = gUnknown_83CBEDC, .affineAnims = gDummySpriteAffineAnimTable, @@ -3625,9 +3625,9 @@ void sub_80878C0(struct Sprite * sprite) } } -void Task_FldEffUnk43(u8 taskId); +void Task_MoveDeoxysRock_Step(u8 taskId); -bool8 FldEff_Unk43(void) +u32 Fldeff_MoveDeoxysRock(void) { u8 taskId; u8 objectEventIdBuffer; @@ -3642,7 +3642,7 @@ bool8 FldEff_Unk43(void) x = (gFieldEffectArguments[3] - x) * 16; y = (gFieldEffectArguments[4] - y) * 16; npc_coords_shift(objectEvent, gFieldEffectArguments[3] + 7, gFieldEffectArguments[4] + 7); - taskId = CreateTask(Task_FldEffUnk43, 0x50); + taskId = CreateTask(Task_MoveDeoxysRock_Step, 0x50); gTasks[taskId].data[1] = objectEvent->spriteId; gTasks[taskId].data[2] = gSprites[objectEvent->spriteId].pos1.x + x; gTasks[taskId].data[3] = gSprites[objectEvent->spriteId].pos1.y + y; @@ -3652,7 +3652,7 @@ bool8 FldEff_Unk43(void) return FALSE; } -void Task_FldEffUnk43(u8 taskId) +void Task_MoveDeoxysRock_Step(u8 taskId) { s16 *data = gTasks[taskId].data; struct Sprite * sprite = &gSprites[data[1]]; @@ -3682,9 +3682,226 @@ void Task_FldEffUnk43(u8 taskId) sprite->pos1.y = data[3]; npc_coords_shift_still(objectEvent); objectEvent->triggerGroundEffectsOnStop = TRUE; - FieldEffectActiveListRemove(FLDEFF_UNK_43); + FieldEffectActiveListRemove(FLDEFF_MOVE_DEOXYS_ROCK); DestroyTask(taskId); } break; } } + +void Task_FldEffUnk44(u8 taskId); +void Unk44Effect_0(s16 *data, u8 taskId); +void Unk44Effect_1(s16 *data, u8 taskId); +void Unk44Effect_2(s16 *data, u8 taskId); +void sub_8087CFC(struct Sprite * sprite); +void SpriteCB_FldEffUnk44(struct Sprite * sprite); + +void (*const sUnk44EffectFuncs[])(s16 *data, u8 taskId) = { + Unk44Effect_0, + Unk44Effect_1, + Unk44Effect_2 +}; + +const struct SpriteFrameImage sImages_FldEffUnk44[] = { + {sFldEffUnk44_Tiles + 0x00, 0x20}, + {sFldEffUnk44_Tiles + 0x10, 0x20}, + {sFldEffUnk44_Tiles + 0x20, 0x20}, + {sFldEffUnk44_Tiles + 0x30, 0x20} +}; + +const union AnimCmd sAnimCmd_FldEffUnk44_0[] = { + ANIMCMD_FRAME(0, 0), + ANIMCMD_END +}; + +const union AnimCmd sAnimCmd_FldEffUnk44_1[] = { + ANIMCMD_FRAME(1, 0), + ANIMCMD_END +}; + +const union AnimCmd sAnimCmd_FldEffUnk44_2[] = { + ANIMCMD_FRAME(2, 0), + ANIMCMD_END +}; + +const union AnimCmd sAnimCmd_FldEffUnk44_3[] = { + ANIMCMD_FRAME(3, 0), + ANIMCMD_END +}; + +const union AnimCmd *const sAnimCmdTable_FldEffUnk44[] = { + sAnimCmd_FldEffUnk44_0, + sAnimCmd_FldEffUnk44_1, + sAnimCmd_FldEffUnk44_2, + sAnimCmd_FldEffUnk44_3 +}; + +const struct SpriteTemplate gUnknown_83CC2A0 = { + .tileTag = 0xFFFF, + .paletteTag = 4371, + .oam = &sOamData_8x8, + .anims = sAnimCmdTable_FldEffUnk44, + .images = sImages_FldEffUnk44, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCB_FldEffUnk44 +}; + +u32 FldEff_Unk44(void) +{ + u8 taskId; + u8 objectEventIdBuffer; + if (!TryGetObjectEventIdByLocalIdAndMap(gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2], &objectEventIdBuffer)) + { + taskId = CreateTask(Task_FldEffUnk44, 0x50); + gTasks[taskId].data[2] = objectEventIdBuffer; + gTasks[taskId].data[6] = gFieldEffectArguments[0]; + gTasks[taskId].data[7] = gFieldEffectArguments[1]; + gTasks[taskId].data[8] = gFieldEffectArguments[2]; + } + else + { + FieldEffectActiveListRemove(FLDEFF_UNK_44); + } + return FALSE; +} + +void sub_8087B14(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + if (data[7] != 0) + { + if (++data[6] > 20) + { + data[6] = 0; + if (data[5] != 0) + data[5]--; + } + } + else + { + data[5] = 4; + } + + if (++data[0] > 1) + { + data[0] = 0; + if (++data[1] & 1) + { + SetCameraPanning(0, -data[5]); + } + else + { + SetCameraPanning(0, data[5]); + } + } + UpdateCameraPanning(); + if (data[5] == 0) + DestroyTask(taskId); +} + +void sub_8087BA8(u8 taskId) +{ + gTasks[taskId].data[7] = 1; +} + +void Task_FldEffUnk44(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + InstallCameraPanAheadCallback(); + SetCameraPanningCallback(NULL); + sUnk44EffectFuncs[data[1]](data, taskId); +} + +void Unk44Effect_0(s16 *data, u8 taskId) +{ + u8 newTaskId = CreateTask(sub_8087B14, 90); + PlaySE(SE_T_KAMI2); + data[5] = newTaskId; + data[1]++; +} + +void Unk44Effect_1(s16 *data, u8 taskId) +{ + if (++data[3] > 0x78) + { + struct Sprite * sprite = &gSprites[gObjectEvents[data[2]].spriteId]; + gObjectEvents[data[2]].invisible = TRUE; + BlendPalettes(0x0000FFFF, 0x10, RGB_WHITE); + BeginNormalPaletteFade(0x0000FFFF, 0, 0x10, 0, RGB_WHITE); + sub_8087CFC(sprite); + PlaySE(SE_T_KAMI); + sub_8087BA8(data[5]); + data[3] = 0; + data[1]++; + } +} + +void Unk44Effect_2(s16 *data, u8 taskId) +{ + if (!gPaletteFade.active && !FuncIsActiveTask(sub_8087B14)) + { + InstallCameraPanAheadCallback(); + RemoveObjectEventByLocalIdAndMap(data[6], data[7], data[8]); + FieldEffectActiveListRemove(FLDEFF_UNK_44); + DestroyTask(taskId); + } +} + +void sub_8087CFC(struct Sprite* sprite) +{ + int i; + int xPos = (s16)gTotalCameraPixelOffsetX + sprite->pos1.x + sprite->pos2.x; + int yPos = (s16)gTotalCameraPixelOffsetY + sprite->pos1.y + sprite->pos2.y - 4; + + for (i = 0; i < 4; i++) + { + u8 spriteId = CreateSprite(&gUnknown_83CC2A0, xPos, yPos, 0); + if (spriteId != MAX_SPRITES) + { + StartSpriteAnim(&gSprites[spriteId], i); + gSprites[spriteId].data[0] = i; + gSprites[spriteId].oam.paletteNum = sprite->oam.paletteNum; + } + } +} + +void SpriteCB_FldEffUnk44(struct Sprite* sprite) +{ + switch (sprite->data[0]) + { + case 0: + sprite->pos1.x -= 16; + sprite->pos1.y -= 12; + break; + case 1: + sprite->pos1.x += 16; + sprite->pos1.y -= 12; + break; + case 2: + sprite->pos1.x -= 16; + sprite->pos1.y += 12; + break; + case 3: + sprite->pos1.x += 16; + sprite->pos1.y += 12; + break; + } + if (sprite->pos1.x < -4 || sprite->pos1.x > 0xF4 || sprite->pos1.y < -4 || sprite->pos1.y > 0xA4) + DestroySprite(sprite); +} + +void Task_FldEffUnk45(u8 taskId) +{ + if (!gPaletteFade.active) + { + FieldEffectActiveListRemove(FLDEFF_UNK_45); + DestroyTask(taskId); + } +} + +void FldEff_Unk45(void) +{ + BlendPalettes(0xFFFFFFFF, 0x10, RGB_WHITE); + BeginNormalPaletteFade(0xFFFFFFFF, -1, 0x0F, 0x00, RGB_WHITE); + CreateTask(Task_FldEffUnk45, 90); +} -- cgit v1.2.3 From 875dde7a0cc2229decf41b1ecbac88addbdc8ea4 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 2 Mar 2020 09:51:21 -0500 Subject: Rename remaining field effect callbacks --- src/field_effect.c | 1 + 1 file changed, 1 insertion(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 59c3677f9..dc6976287 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -3899,6 +3899,7 @@ void Task_FldEffUnk45(u8 taskId) } } +// Bug: Return value should be u32, not void void FldEff_Unk45(void) { BlendPalettes(0xFFFFFFFF, 0x10, RGB_WHITE); -- cgit v1.2.3 From 2f8ac698c8a03954d3bf0d05a9ef13dd447eaf53 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 2 Mar 2020 09:57:54 -0500 Subject: Static symbols in field_effect.c --- src/field_effect.c | 967 ++++++++++++++++++++++++++--------------------------- 1 file changed, 483 insertions(+), 484 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index dc6976287..5553f16dc 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -34,42 +34,42 @@ static u8 sFieldEffectActiveList[FIELD_EFFECT_COUNT]; -void FieldEffectActiveListAdd(u8 fldeff); -bool8 FieldEffectCmd_loadtiles(const u8 **script, u32 *result); -bool8 FieldEffectCmd_loadfadedpal(const u8 **script, u32 *result); -bool8 FieldEffectCmd_loadpal(const u8 **script, u32 *result); -bool8 FieldEffectCmd_callnative(const u8 **script, u32 *result); -bool8 FieldEffectCmd_end(const u8 **script, u32 *result); -bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result); -bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result); -bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result); -void FieldEffectScript_LoadTiles(const u8 **script); -void FieldEffectScript_LoadFadedPal(const u8 **script); -void FieldEffectScript_LoadPal(const u8 **script); -void FieldEffectScript_CallNative(const u8 **script, u32 *result); -void FieldEffectFreeTilesIfUnused(u16 tilesTag); -void FieldEffectFreePaletteIfUnused(u8 paletteNum); -void Task_PokecenterHeal(u8 taskId); -void SpriteCB_PokeballGlow(struct Sprite * sprite); -void SpriteCB_PokecenterMonitor(struct Sprite * sprite); -void SpriteCB_HallOfFameMonitor(struct Sprite * sprite); - -const u16 sNewGameOakObjectSpriteTiles[] = INCBIN_U16("graphics/field_effects/unk_83CA770.4bpp"); -const u16 sNewGameOakObjectPals[] = INCBIN_U16("graphics/field_effects/unk_83CAF70.gbapal"); -const u16 gUnknown_83CAF90[] = INCBIN_U16("graphics/field_effects/unk_83CAF90.4bpp"); -const u16 gUnknown_83CAFB0[] = INCBIN_U16("graphics/field_effects/unk_83CAFB0.gbapal"); -const u16 gUnknown_83CAFD0[] = INCBIN_U16("graphics/field_effects/unk_83CAFD0.4bpp"); -const u16 gUnknown_83CB3D0[] = INCBIN_U16("graphics/field_effects/unk_83CB3D0.gbapal"); -const u16 gUnknown_83CB3F0[] = INCBIN_U16("graphics/field_effects/unk_83CB3F0.4bpp"); -const u16 gFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CB5F0.4bpp"); -const u16 gFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CB7F0.gbapal"); -const u16 gFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CB810.bin"); -const u16 gDarknessFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp"); -const u16 gDarknessFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal"); -const u16 gDarknessFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin"); -const u16 sFldEffUnk44_Tiles[] = INCBIN_U16("graphics/field_effects/unk_83CBDB0.4bpp"); - -bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = { +static void FieldEffectActiveListAdd(u8 fldeff); +static bool8 FieldEffectCmd_loadtiles(const u8 **script, u32 *result); +static bool8 FieldEffectCmd_loadfadedpal(const u8 **script, u32 *result); +static bool8 FieldEffectCmd_loadpal(const u8 **script, u32 *result); +static bool8 FieldEffectCmd_callnative(const u8 **script, u32 *result); +static bool8 FieldEffectCmd_end(const u8 **script, u32 *result); +static bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result); +static bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result); +static bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result); +static void FieldEffectScript_LoadTiles(const u8 **script); +static void FieldEffectScript_LoadFadedPal(const u8 **script); +static void FieldEffectScript_LoadPal(const u8 **script); +static void FieldEffectScript_CallNative(const u8 **script, u32 *result); +static void FieldEffectFreeTilesIfUnused(u16 tilesTag); +static void FieldEffectFreePaletteIfUnused(u8 paletteNum); +static void Task_PokecenterHeal(u8 taskId); +static void SpriteCB_PokeballGlow(struct Sprite * sprite); +static void SpriteCB_PokecenterMonitor(struct Sprite * sprite); +static void SpriteCB_HallOfFameMonitor(struct Sprite * sprite); + +static const u16 sNewGameOakObjectSpriteTiles[] = INCBIN_U16("graphics/field_effects/unk_83CA770.4bpp"); +static const u16 sNewGameOakObjectPals[] = INCBIN_U16("graphics/field_effects/unk_83CAF70.gbapal"); +static const u16 gUnknown_83CAF90[] = INCBIN_U16("graphics/field_effects/unk_83CAF90.4bpp"); +static const u16 gUnknown_83CAFB0[] = INCBIN_U16("graphics/field_effects/unk_83CAFB0.gbapal"); +static const u16 gUnknown_83CAFD0[] = INCBIN_U16("graphics/field_effects/unk_83CAFD0.4bpp"); +static const u16 gUnknown_83CB3D0[] = INCBIN_U16("graphics/field_effects/unk_83CB3D0.gbapal"); +static const u16 gUnknown_83CB3F0[] = INCBIN_U16("graphics/field_effects/unk_83CB3F0.4bpp"); +static const u16 gFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CB5F0.4bpp"); +static const u16 gFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CB7F0.gbapal"); +static const u16 gFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CB810.bin"); +static const u16 gDarknessFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp"); +static const u16 gDarknessFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal"); +static const u16 gDarknessFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin"); +static const u16 sFldEffUnk44_Tiles[] = INCBIN_U16("graphics/field_effects/unk_83CBDB0.4bpp"); + +static bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = { FieldEffectCmd_loadtiles, FieldEffectCmd_loadfadedpal, FieldEffectCmd_loadpal, @@ -80,7 +80,7 @@ bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = { FieldEffectCmd_loadfadedpal_callnative }; -const struct OamData gNewGameOakOamAttributes = { +static const struct OamData gNewGameOakOamAttributes = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, @@ -96,7 +96,7 @@ const struct OamData gNewGameOakOamAttributes = { .affineParam = 0 }; -const struct OamData sOamData_8x8 = { +static const struct OamData sOamData_8x8 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, @@ -112,7 +112,7 @@ const struct OamData sOamData_8x8 = { .affineParam = 0 }; -const struct OamData sOamData_16x16 = { +static const struct OamData sOamData_16x16 = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, @@ -128,24 +128,24 @@ const struct OamData sOamData_16x16 = { .affineParam = 0 }; -const struct SpriteFrameImage gNewGameOakObjectSpriteFrames[] = { +static const struct SpriteFrameImage gNewGameOakObjectSpriteFrames[] = { {sNewGameOakObjectSpriteTiles, 0x800} }; -const struct SpritePalette gNewGameOakObjectPaletteInfo = { +static const struct SpritePalette gNewGameOakObjectPaletteInfo = { sNewGameOakObjectPals, 4102 }; -const union AnimCmd gNewGameOakAnim[] = { +static const union AnimCmd gNewGameOakAnim[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; -const union AnimCmd *const gNewGameOakAnimTable[] = { +static const union AnimCmd *const gNewGameOakAnimTable[] = { gNewGameOakAnim }; -const struct SpriteTemplate gNewGameOakObjectTemplate = { +static const struct SpriteTemplate gNewGameOakObjectTemplate = { .tileTag = 0xFFFF, .paletteTag = 4102, .oam = &gNewGameOakOamAttributes, @@ -163,7 +163,7 @@ const struct SpritePalette gUnknown_83CBEA4 = { gUnknown_83CB3D0, 4112 }; -const struct OamData gOamData_83CBEAC = { +static const struct OamData gOamData_83CBEAC = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, @@ -179,25 +179,25 @@ const struct OamData gOamData_83CBEAC = { .affineParam = 0 }; -const struct SpriteFrameImage gUnknown_83CBEB4[] = { +static const struct SpriteFrameImage gUnknown_83CBEB4[] = { {gUnknown_83CAF90, 0x20} }; -const struct SpriteFrameImage gUnknown_83CBEBC[] = { +static const struct SpriteFrameImage gUnknown_83CBEBC[] = { {gUnknown_83CAFD0 + 0x000, 0x100}, {gUnknown_83CAFD0 + 0x080, 0x100}, {gUnknown_83CAFD0 + 0x100, 0x100}, {gUnknown_83CAFD0 + 0x180, 0x100} }; -const struct SpriteFrameImage gUnknown_83CBEDC[] = { +static const struct SpriteFrameImage gUnknown_83CBEDC[] = { {gUnknown_83CB3F0 + 0x00, 0x80}, {gUnknown_83CB3F0 + 0x40, 0x80}, {gUnknown_83CB3F0 + 0x80, 0x80}, {gUnknown_83CB3F0 + 0xC0, 0x80} }; -const struct Subsprite gUnknown_83CBEFC[] = +static const struct Subsprite gUnknown_83CBEFC[] = { { .x = -12, @@ -230,9 +230,9 @@ const struct Subsprite gUnknown_83CBEFC[] = } }; -const struct SubspriteTable gUnknown_83CBF0C = subsprite_table(gUnknown_83CBEFC); +static const struct SubspriteTable gUnknown_83CBF0C = subsprite_table(gUnknown_83CBEFC); -const struct Subsprite gUnknown_83CBF14[] = +static const struct Subsprite gUnknown_83CBF14[] = { { .x = -32, @@ -265,14 +265,14 @@ const struct Subsprite gUnknown_83CBF14[] = } }; -const struct SubspriteTable gUnknown_83CBF24 = subsprite_table(gUnknown_83CBF14); +static const struct SubspriteTable gUnknown_83CBF24 = subsprite_table(gUnknown_83CBF14); -const union AnimCmd gUnknown_83CBF2C[] = { +static const union AnimCmd gUnknown_83CBF2C[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_JUMP(0) }; -const union AnimCmd gUnknown_83CBF34[] = { +static const union AnimCmd gUnknown_83CBF34[] = { ANIMCMD_FRAME(1, 5), ANIMCMD_FRAME(2, 5), ANIMCMD_FRAME(3, 7), @@ -283,12 +283,12 @@ const union AnimCmd gUnknown_83CBF34[] = { ANIMCMD_END }; -const union AnimCmd *const gUnknown_83CBF54[] = { +static const union AnimCmd *const gUnknown_83CBF54[] = { gUnknown_83CBF2C, gUnknown_83CBF34 }; -const union AnimCmd gUnknown_83CBF5C[] = { +static const union AnimCmd gUnknown_83CBF5C[] = { ANIMCMD_FRAME(3, 8), ANIMCMD_FRAME(2, 8), ANIMCMD_FRAME(1, 8), @@ -301,11 +301,11 @@ const union AnimCmd gUnknown_83CBF5C[] = { ANIMCMD_END }; -const union AnimCmd *const gUnknown_83CBF84[] = { +static const union AnimCmd *const gUnknown_83CBF84[] = { gUnknown_83CBF5C }; -const struct SpriteTemplate gUnknown_83CBF88 = { +static const struct SpriteTemplate gUnknown_83CBF88 = { .tileTag = 65535, .paletteTag = 4103, .oam = &sOamData_8x8, @@ -315,7 +315,7 @@ const struct SpriteTemplate gUnknown_83CBF88 = { .callback = SpriteCB_PokeballGlow }; -const struct SpriteTemplate gUnknown_83CBFA0 = { +static const struct SpriteTemplate gUnknown_83CBFA0 = { .tileTag = 65535, .paletteTag = 4103, .oam = &gOamData_83CBEAC, @@ -325,7 +325,7 @@ const struct SpriteTemplate gUnknown_83CBFA0 = { .callback = SpriteCB_PokecenterMonitor }; -const struct SpriteTemplate gUnknown_83CBFB8 = { +static const struct SpriteTemplate gUnknown_83CBFB8 = { .tileTag = 65535, .paletteTag = 4112, .oam = &sOamData_16x16, @@ -347,39 +347,39 @@ u32 FieldEffectStart(u8 fldeff) return result; } -bool8 FieldEffectCmd_loadtiles(const u8 **script, u32 *result) +static bool8 FieldEffectCmd_loadtiles(const u8 **script, u32 *result) { (*script)++; FieldEffectScript_LoadTiles(script); return TRUE; } -bool8 FieldEffectCmd_loadfadedpal(const u8 **script, u32 *result) +static bool8 FieldEffectCmd_loadfadedpal(const u8 **script, u32 *result) { (*script)++; FieldEffectScript_LoadFadedPal(script); return TRUE; } -bool8 FieldEffectCmd_loadpal(const u8 **script, u32 *result) +static bool8 FieldEffectCmd_loadpal(const u8 **script, u32 *result) { (*script)++; FieldEffectScript_LoadPal(script); return TRUE; } -bool8 FieldEffectCmd_callnative(const u8 **script, u32 *result) +static bool8 FieldEffectCmd_callnative(const u8 **script, u32 *result) { (*script)++; FieldEffectScript_CallNative(script, result); return TRUE; } -bool8 FieldEffectCmd_end(const u8 **script, u32 *result) +static bool8 FieldEffectCmd_end(const u8 **script, u32 *result) { return FALSE; } -bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result) +static bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result) { (*script)++; FieldEffectScript_LoadTiles(script); @@ -388,7 +388,7 @@ bool8 FieldEffectCmd_loadgfx_callnative(const u8 **script, u32 *result) return TRUE; } -bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result) +static bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result) { (*script)++; FieldEffectScript_LoadTiles(script); @@ -396,7 +396,7 @@ bool8 FieldEffectCmd_loadtiles_callnative(const u8 **script, u32 *result) return TRUE; } -bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result) +static bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result) { (*script)++; FieldEffectScript_LoadFadedPal(script); @@ -404,12 +404,12 @@ bool8 FieldEffectCmd_loadfadedpal_callnative(const u8 **script, u32 *result) return TRUE; } -u32 FieldEffectScript_ReadWord(const u8 **script) +static u32 FieldEffectScript_ReadWord(const u8 **script) { return T2_READ_32(*script); } -void FieldEffectScript_LoadTiles(const u8 **script) +static void FieldEffectScript_LoadTiles(const u8 **script) { const struct SpriteSheet * spriteSheet = (const struct SpriteSheet * )FieldEffectScript_ReadWord(script); if (GetSpriteTileStartByTag(spriteSheet->tag) == 0xFFFF) @@ -439,7 +439,7 @@ void sub_8083598(u8 paletteIdx) CpuFastCopy(&gPlttBufferUnfaded[(paletteIdx + 16) * 16], &gPlttBufferFaded[(paletteIdx + 16) * 16], 0x20); } -void FieldEffectScript_LoadFadedPal(const u8 **script) +static void FieldEffectScript_LoadFadedPal(const u8 **script) { const struct SpritePalette * spritePalette = (const struct SpritePalette * )FieldEffectScript_ReadWord(script); u8 idx = IndexOfSpritePaletteTag(spritePalette->tag); @@ -450,7 +450,7 @@ void FieldEffectScript_LoadFadedPal(const u8 **script) *script += sizeof(u32); } -void FieldEffectScript_LoadPal(const u8 **script) +static void FieldEffectScript_LoadPal(const u8 **script) { const struct SpritePalette * spritePalette = (const struct SpritePalette * )FieldEffectScript_ReadWord(script); u8 idx = IndexOfSpritePaletteTag(spritePalette->tag); @@ -460,14 +460,14 @@ void FieldEffectScript_LoadPal(const u8 **script) *script += sizeof(u32); } -void FieldEffectScript_CallNative(const u8 **script, u32 *result) +static void FieldEffectScript_CallNative(const u8 **script, u32 *result) { u32 (*func)(void) = (u32 (*)(void))FieldEffectScript_ReadWord(script); *result = func(); *script += sizeof(u32); } -void FieldEffectFreeGraphicsResources(struct Sprite * sprite) +static void FieldEffectFreeGraphicsResources(struct Sprite * sprite) { u16 tileStart = sprite->sheetTileStart; u8 paletteNum = sprite->oam.paletteNum; @@ -482,7 +482,7 @@ void FieldEffectStop(struct Sprite * sprite, u8 fldeff) FieldEffectActiveListRemove(fldeff); } -void FieldEffectFreeTilesIfUnused(u16 tileStart) +static void FieldEffectFreeTilesIfUnused(u16 tileStart) { u8 i; u16 tileTag = GetSpriteTileTagByTileStart(tileStart); @@ -496,7 +496,7 @@ void FieldEffectFreeTilesIfUnused(u16 tileStart) FreeSpriteTilesByTag(tileTag); } -void FieldEffectFreePaletteIfUnused(u8 paletteNum) +static void FieldEffectFreePaletteIfUnused(u8 paletteNum) { u8 i; u16 paletteTag = GetSpritePaletteTagByPaletteNum(paletteNum); @@ -519,7 +519,7 @@ void FieldEffectActiveListClear(void) } } -void FieldEffectActiveListAdd(u8 fldeff) +static void FieldEffectActiveListAdd(u8 fldeff) { u8 i; for (i = 0; i < FIELD_EFFECT_COUNT; i++) @@ -573,13 +573,13 @@ u8 CreateTrainerSprite(u8 trainerSpriteID, s16 x, s16 y, u8 subpriority, u8 *buf return CreateSprite(&spriteTemplate, x, y, subpriority); } -void LoadTrainerGfx_TrainerCard(u8 gender, u16 palOffset, u8 *dest) +static void LoadTrainerGfx_TrainerCard(u8 gender, u16 palOffset, u8 *dest) { LZDecompressVram(gTrainerFrontPicTable[gender].data, dest); LoadCompressedPalette(gTrainerFrontPicPaletteTable[gender].data, palOffset, 0x20); } -u8 AddNewGameBirchObject(s16 x, s16 y, u8 subpriority) +static u8 AddNewGameBirchObject(s16 x, s16 y, u8 subpriority) { LoadSpritePalette(&gNewGameOakObjectPaletteInfo); return CreateSprite(&gNewGameOakObjectTemplate, x, y, subpriority); @@ -595,7 +595,7 @@ u8 CreateMonSprite_PicBox(u16 species, s16 x, s16 y, u8 subpriority) return spriteId; } -u8 CreateMonSprite_FieldMove(u16 species, u32 otId, u32 personality, s16 x, s16 y, u8 subpriority) +static u8 CreateMonSprite_FieldMove(u16 species, u32 otId, u32 personality, s16 x, s16 y, u8 subpriority) { const struct CompressedSpritePalette * spritePalette = GetMonSpritePalStructFromOtIdPersonality(species, otId, personality); u16 spriteId = CreateMonPicSprite_HandleDeoxys(species, otId, personality, 1, x, y, 0, spritePalette->tag); @@ -638,7 +638,7 @@ void MultiplyInvertedPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b) } // r, g, b are between 0 and 16 -void MultiplyPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b) +static void MultiplyPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b) { int curRed; int curGreen; @@ -658,43 +658,43 @@ void MultiplyPaletteRGBComponents(u16 i, u8 r, u8 g, u8 b) gPlttBufferFaded[i] = outPal; } -void PokecenterHealEffect_0(struct Task * task); -void PokecenterHealEffect_1(struct Task * task); -void PokecenterHealEffect_2(struct Task * task); -void PokecenterHealEffect_3(struct Task * task); -void HallOfFameRecordEffect_0(struct Task * task); -void HallOfFameRecordEffect_1(struct Task * task); -void HallOfFameRecordEffect_2(struct Task * task); -void HallOfFameRecordEffect_3(struct Task * task); -void Task_HallOfFameRecord(u8 taskId); -u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare); -void SpriteCB_PokeballGlowEffect(struct Sprite * sprite); -void PokeballGlowEffect_0(struct Sprite * sprite); -void PokeballGlowEffect_1(struct Sprite * sprite); -void PokeballGlowEffect_2(struct Sprite * sprite); -void PokeballGlowEffect_3(struct Sprite * sprite); -void PokeballGlowEffect_4(struct Sprite * sprite); -void PokeballGlowEffect_5(struct Sprite * sprite); -void PokeballGlowEffect_6(struct Sprite * sprite); -void PokeballGlowEffect_7(struct Sprite * sprite); -u8 PokecenterHealEffectHelper(s32 x, s32 y); -void HallOfFameRecordEffectHelper(s32 x, s32 y); - -void (*const sPokecenterHealTaskCBTable[])(struct Task * ) = { +static void PokecenterHealEffect_0(struct Task * task); +static void PokecenterHealEffect_1(struct Task * task); +static void PokecenterHealEffect_2(struct Task * task); +static void PokecenterHealEffect_3(struct Task * task); +static void HallOfFameRecordEffect_0(struct Task * task); +static void HallOfFameRecordEffect_1(struct Task * task); +static void HallOfFameRecordEffect_2(struct Task * task); +static void HallOfFameRecordEffect_3(struct Task * task); +static void Task_HallOfFameRecord(u8 taskId); +static u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare); +static void SpriteCB_PokeballGlowEffect(struct Sprite * sprite); +static void PokeballGlowEffect_0(struct Sprite * sprite); +static void PokeballGlowEffect_1(struct Sprite * sprite); +static void PokeballGlowEffect_2(struct Sprite * sprite); +static void PokeballGlowEffect_3(struct Sprite * sprite); +static void PokeballGlowEffect_4(struct Sprite * sprite); +static void PokeballGlowEffect_5(struct Sprite * sprite); +static void PokeballGlowEffect_6(struct Sprite * sprite); +static void PokeballGlowEffect_7(struct Sprite * sprite); +static u8 PokecenterHealEffectHelper(s32 x, s32 y); +static void HallOfFameRecordEffectHelper(s32 x, s32 y); + +static void (*const sPokecenterHealTaskCBTable[])(struct Task * ) = { PokecenterHealEffect_0, PokecenterHealEffect_1, PokecenterHealEffect_2, PokecenterHealEffect_3 }; -void (*const sHallOfFameRecordTaskCBTable[])(struct Task * ) = { +static void (*const sHallOfFameRecordTaskCBTable[])(struct Task * ) = { HallOfFameRecordEffect_0, HallOfFameRecordEffect_1, HallOfFameRecordEffect_2, HallOfFameRecordEffect_3 }; -void (*const sPokeballGlowSpriteCBTable[])(struct Sprite * ) = { +static void (*const sPokeballGlowSpriteCBTable[])(struct Sprite * ) = { PokeballGlowEffect_0, PokeballGlowEffect_1, PokeballGlowEffect_2, @@ -720,20 +720,20 @@ bool8 FldEff_PokecenterHeal(void) return FALSE; } -void Task_PokecenterHeal(u8 taskId) +static void Task_PokecenterHeal(u8 taskId) { struct Task * task = &gTasks[taskId]; sPokecenterHealTaskCBTable[task->data[0]](task); } -void PokecenterHealEffect_0(struct Task * task) +static void PokecenterHealEffect_0(struct Task * task) { task->data[0]++; task->data[6] = CreatePokeballGlowSprite(task->data[1], task->data[2], task->data[3], TRUE); task->data[7] = PokecenterHealEffectHelper(task->data[4], task->data[5]); } -void PokecenterHealEffect_1(struct Task * task) +static void PokecenterHealEffect_1(struct Task * task) { if (gSprites[task->data[6]].data[0] > 1) { @@ -742,7 +742,7 @@ void PokecenterHealEffect_1(struct Task * task) } } -void PokecenterHealEffect_2(struct Task * task) +static void PokecenterHealEffect_2(struct Task * task) { if (gSprites[task->data[6]].data[0] > 4) { @@ -750,7 +750,7 @@ void PokecenterHealEffect_2(struct Task * task) } } -void PokecenterHealEffect_3(struct Task * task) +static void PokecenterHealEffect_3(struct Task * task) { if (gSprites[task->data[6]].data[0] > 6) { @@ -760,7 +760,6 @@ void PokecenterHealEffect_3(struct Task * task) } } - bool8 FldEff_HallOfFameRecord(void) { u8 nPokemon; @@ -774,21 +773,21 @@ bool8 FldEff_HallOfFameRecord(void) return FALSE; } -void Task_HallOfFameRecord(u8 taskId) +static void Task_HallOfFameRecord(u8 taskId) { struct Task * task; task = &gTasks[taskId]; sHallOfFameRecordTaskCBTable[task->data[0]](task); } -void HallOfFameRecordEffect_0(struct Task * task) +static void HallOfFameRecordEffect_0(struct Task * task) { u8 taskId; task->data[0]++; task->data[6] = CreatePokeballGlowSprite(task->data[1], task->data[2], task->data[3], FALSE); } -void HallOfFameRecordEffect_1(struct Task * task) +static void HallOfFameRecordEffect_1(struct Task * task) { if (gSprites[task->data[6]].data[0] > 1) { @@ -798,7 +797,7 @@ void HallOfFameRecordEffect_1(struct Task * task) } } -void HallOfFameRecordEffect_2(struct Task * task) +static void HallOfFameRecordEffect_2(struct Task * task) { if (gSprites[task->data[6]].data[0] > 4) { @@ -806,7 +805,7 @@ void HallOfFameRecordEffect_2(struct Task * task) } } -void HallOfFameRecordEffect_3(struct Task * task) +static void HallOfFameRecordEffect_3(struct Task * task) { if (gSprites[task->data[6]].data[0] > 6) { @@ -816,7 +815,7 @@ void HallOfFameRecordEffect_3(struct Task * task) } } -u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare) +static u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare) { u8 spriteId; struct Sprite * sprite; @@ -831,12 +830,12 @@ u8 CreatePokeballGlowSprite(s16 duration, s16 x, s16 y, bool16 fanfare) return spriteId; } -void SpriteCB_PokeballGlowEffect(struct Sprite * sprite) +static void SpriteCB_PokeballGlowEffect(struct Sprite * sprite) { sPokeballGlowSpriteCBTable[sprite->data[0]](sprite); } -const struct Coords16 gUnknown_83CC010[] = { +static const struct Coords16 gUnknown_83CC010[] = { {0, 0}, {6, 0}, {0, 4}, @@ -845,11 +844,11 @@ const struct Coords16 gUnknown_83CC010[] = { {6, 8} }; -const u8 gUnknown_83CC028[] = {16, 12, 8, 0}; -const u8 gUnknown_83CC02C[] = {16, 12, 8, 0}; -const u8 gUnknown_83CC030[] = { 0, 0, 0, 0}; +static const u8 gUnknown_83CC028[] = {16, 12, 8, 0}; +static const u8 gUnknown_83CC02C[] = {16, 12, 8, 0}; +static const u8 gUnknown_83CC030[] = { 0, 0, 0, 0}; -void PokeballGlowEffect_0(struct Sprite * sprite) +static void PokeballGlowEffect_0(struct Sprite * sprite) { u8 endSpriteId; if (sprite->data[1] == 0 || (--sprite->data[1]) == 0) @@ -869,7 +868,7 @@ void PokeballGlowEffect_0(struct Sprite * sprite) } } -void PokeballGlowEffect_1(struct Sprite * sprite) +static void PokeballGlowEffect_1(struct Sprite * sprite) { if ((--sprite->data[1]) == 0) { @@ -884,7 +883,7 @@ void PokeballGlowEffect_1(struct Sprite * sprite) } } -void PokeballGlowEffect_2(struct Sprite * sprite) +static void PokeballGlowEffect_2(struct Sprite * sprite) { u8 phase; if ((--sprite->data[1]) == 0) @@ -914,7 +913,7 @@ void PokeballGlowEffect_2(struct Sprite * sprite) } } -void PokeballGlowEffect_3(struct Sprite * sprite) +static void PokeballGlowEffect_3(struct Sprite * sprite) { u8 phase; if ((--sprite->data[1]) == 0) @@ -936,7 +935,7 @@ void PokeballGlowEffect_3(struct Sprite * sprite) MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); } -void PokeballGlowEffect_4(struct Sprite * sprite) +static void PokeballGlowEffect_4(struct Sprite * sprite) { if ((--sprite->data[1]) == 0) { @@ -944,12 +943,12 @@ void PokeballGlowEffect_4(struct Sprite * sprite) } } -void PokeballGlowEffect_5(struct Sprite * sprite) +static void PokeballGlowEffect_5(struct Sprite * sprite) { sprite->data[0]++; } -void PokeballGlowEffect_6(struct Sprite * sprite) +static void PokeballGlowEffect_6(struct Sprite * sprite) { if (sprite->data[5] == 0 || IsFanfareTaskInactive()) { @@ -957,17 +956,17 @@ void PokeballGlowEffect_6(struct Sprite * sprite) } } -void PokeballGlowEffect_7(struct Sprite * sprite) +static void PokeballGlowEffect_7(struct Sprite * sprite) { } -void SpriteCB_PokeballGlow(struct Sprite * sprite) +static void SpriteCB_PokeballGlow(struct Sprite * sprite) { if (gSprites[sprite->data[0]].data[0] > 4) FieldEffectFreeGraphicsResources(sprite); } -u8 PokecenterHealEffectHelper(s32 x, s32 y) +static u8 PokecenterHealEffectHelper(s32 x, s32 y) { u8 spriteId; struct Sprite * sprite; @@ -978,7 +977,7 @@ u8 PokecenterHealEffectHelper(s32 x, s32 y) return spriteId; } -void SpriteCB_PokecenterMonitor(struct Sprite * sprite) +static void SpriteCB_PokecenterMonitor(struct Sprite * sprite) { if (sprite->data[0] != 0) { @@ -990,21 +989,21 @@ void SpriteCB_PokecenterMonitor(struct Sprite * sprite) FieldEffectFreeGraphicsResources(sprite); } -void HallOfFameRecordEffectHelper(s32 x, s32 y) +static void HallOfFameRecordEffectHelper(s32 x, s32 y) { CreateSpriteAtEnd(&gUnknown_83CBFB8, x, y, 0); } -void SpriteCB_HallOfFameMonitor(struct Sprite * sprite) +static void SpriteCB_HallOfFameMonitor(struct Sprite * sprite) { if (sprite->animEnded) FieldEffectFreeGraphicsResources(sprite); } -void FieldCallback_Fly(void); -void Task_FlyOut(u8 taskId); -void FieldCallback_FlyArrive(void); -void Task_FlyIn(u8 taskId); +static void FieldCallback_Fly(void); +static void Task_FlyOut(u8 taskId); +static void FieldCallback_FlyArrive(void); +static void Task_FlyIn(u8 taskId); void ReturnToFieldFromFlyMapSelect(void) { @@ -1012,7 +1011,7 @@ void ReturnToFieldFromFlyMapSelect(void) gFieldCallback = FieldCallback_Fly; } -void FieldCallback_Fly(void) +static void FieldCallback_Fly(void) { FadeInFromBlack(); CreateTask(Task_FlyOut, 0); @@ -1021,7 +1020,7 @@ void FieldCallback_Fly(void) gFieldCallback = NULL; } -void Task_FlyOut(u8 taskId) +static void Task_FlyOut(u8 taskId) { struct Task * task; task = &gTasks[taskId]; @@ -1045,7 +1044,7 @@ void Task_FlyOut(u8 taskId) } } -void FieldCallback_FlyArrive(void) +static void FieldCallback_FlyArrive(void) { Overworld_PlaySpecialMapMusic(); FadeInFromBlack(); @@ -1060,7 +1059,7 @@ void FieldCallback_FlyArrive(void) gFieldCallback = NULL; } -void Task_FlyIn(u8 taskId) +static void Task_FlyIn(u8 taskId) { struct Task * task; task = &gTasks[taskId]; @@ -1081,16 +1080,16 @@ void Task_FlyIn(u8 taskId) } } -void Task_FallWarpFieldEffect(u8 taskId); -bool8 FallWarpEffect_1(struct Task * task); -bool8 FallWarpEffect_2(struct Task * task); -bool8 FallWarpEffect_3(struct Task * task); -bool8 FallWarpEffect_4(struct Task * task); -bool8 FallWarpEffect_5(struct Task * task); -bool8 FallWarpEffect_6(struct Task * task); -bool8 FallWarpEffect_7(struct Task * task); +static void Task_FallWarpFieldEffect(u8 taskId); +static bool8 FallWarpEffect_1(struct Task * task); +static bool8 FallWarpEffect_2(struct Task * task); +static bool8 FallWarpEffect_3(struct Task * task); +static bool8 FallWarpEffect_4(struct Task * task); +static bool8 FallWarpEffect_5(struct Task * task); +static bool8 FallWarpEffect_6(struct Task * task); +static bool8 FallWarpEffect_7(struct Task * task); -bool8 (*const sFallWarpEffectCBPtrs[])(struct Task * task) = { +static bool8 (*const sFallWarpEffectCBPtrs[])(struct Task * task) = { FallWarpEffect_1, FallWarpEffect_2, FallWarpEffect_3, @@ -1111,14 +1110,14 @@ void FieldCB_FallWarpExit(void) gFieldCallback = NULL; } -void Task_FallWarpFieldEffect(u8 taskId) +static void Task_FallWarpFieldEffect(u8 taskId) { struct Task * task = &gTasks[taskId]; while (sFallWarpEffectCBPtrs[task->data[0]](task)) ; } -bool8 FallWarpEffect_1(struct Task * task) +static bool8 FallWarpEffect_1(struct Task * task) { struct ObjectEvent * playerObject; struct Sprite * playerSprite; @@ -1136,7 +1135,7 @@ bool8 FallWarpEffect_1(struct Task * task) return TRUE; } -bool8 FallWarpEffect_2(struct Task * task) +static bool8 FallWarpEffect_2(struct Task * task) { if (IsWeatherNotFadingIn()) { @@ -1145,7 +1144,7 @@ bool8 FallWarpEffect_2(struct Task * task) return FALSE; } -bool8 FallWarpEffect_3(struct Task * task) +static bool8 FallWarpEffect_3(struct Task * task) { struct Sprite * sprite; s16 centerToCornerVecY; @@ -1160,7 +1159,7 @@ bool8 FallWarpEffect_3(struct Task * task) return FALSE; } -bool8 FallWarpEffect_4(struct Task * task) +static bool8 FallWarpEffect_4(struct Task * task) { struct ObjectEvent * objectEvent; struct Sprite * sprite; @@ -1194,7 +1193,7 @@ bool8 FallWarpEffect_4(struct Task * task) return FALSE; } -bool8 FallWarpEffect_5(struct Task * task) +static bool8 FallWarpEffect_5(struct Task * task) { task->data[0]++; task->data[1] = 4; @@ -1203,7 +1202,7 @@ bool8 FallWarpEffect_5(struct Task * task) return TRUE; } -bool8 FallWarpEffect_6(struct Task * task) +static bool8 FallWarpEffect_6(struct Task * task) { SetCameraPanning(0, task->data[1]); task->data[1] = -task->data[1]; @@ -1219,7 +1218,7 @@ bool8 FallWarpEffect_6(struct Task * task) return FALSE; } -bool8 FallWarpEffect_7(struct Task * task) +static bool8 FallWarpEffect_7(struct Task * task) { s16 x, y; gPlayerAvatar.preventStep = FALSE; @@ -1239,28 +1238,28 @@ bool8 FallWarpEffect_7(struct Task * task) return FALSE; } -void Task_EscalatorWarpFieldEffect(u8 taskId); -bool8 EscalatorWarpEffect_1(struct Task * task); -bool8 EscalatorWarpEffect_2(struct Task * task); -bool8 EscalatorWarpEffect_3(struct Task * task); -bool8 EscalatorWarpEffect_4(struct Task * task); -bool8 EscalatorWarpEffect_5(struct Task * task); -bool8 EscalatorWarpEffect_6(struct Task * task); -void Escalator_AnimatePlayerGoingDown(struct Task * task); -void Escalator_AnimatePlayerGoingUp(struct Task * task); -void Escalator_BeginFadeOutToNewMap(void); -void Escalator_TransitionToWarpInEffect(void); -void FieldCB_EscalatorWarpIn(void); -void Task_EscalatorWarpInFieldEffect(u8 taskId); -bool8 EscalatorWarpInEffect_1(struct Task * task); -bool8 EscalatorWarpInEffect_2(struct Task * task); -bool8 EscalatorWarpInEffect_3(struct Task * task); -bool8 EscalatorWarpInEffect_4(struct Task * task); -bool8 EscalatorWarpInEffect_5(struct Task * task); -bool8 EscalatorWarpInEffect_6(struct Task * task); -bool8 EscalatorWarpInEffect_7(struct Task * task); - -bool8 (*const sEscalatorWarpFieldEffectFuncs[])(struct Task * task) = { +static void Task_EscalatorWarpFieldEffect(u8 taskId); +static bool8 EscalatorWarpEffect_1(struct Task * task); +static bool8 EscalatorWarpEffect_2(struct Task * task); +static bool8 EscalatorWarpEffect_3(struct Task * task); +static bool8 EscalatorWarpEffect_4(struct Task * task); +static bool8 EscalatorWarpEffect_5(struct Task * task); +static bool8 EscalatorWarpEffect_6(struct Task * task); +static void Escalator_AnimatePlayerGoingDown(struct Task * task); +static void Escalator_AnimatePlayerGoingUp(struct Task * task); +static void Escalator_BeginFadeOutToNewMap(void); +static void Escalator_TransitionToWarpInEffect(void); +static void FieldCB_EscalatorWarpIn(void); +static void Task_EscalatorWarpInFieldEffect(u8 taskId); +static bool8 EscalatorWarpInEffect_1(struct Task * task); +static bool8 EscalatorWarpInEffect_2(struct Task * task); +static bool8 EscalatorWarpInEffect_3(struct Task * task); +static bool8 EscalatorWarpInEffect_4(struct Task * task); +static bool8 EscalatorWarpInEffect_5(struct Task * task); +static bool8 EscalatorWarpInEffect_6(struct Task * task); +static bool8 EscalatorWarpInEffect_7(struct Task * task); + +static bool8 (*const sEscalatorWarpFieldEffectFuncs[])(struct Task * task) = { EscalatorWarpEffect_1, EscalatorWarpEffect_2, EscalatorWarpEffect_3, @@ -1277,14 +1276,14 @@ void StartEscalatorWarp(u8 metatileBehavior, u8 priority) gTasks[taskId].data[1] = 1; } -void Task_EscalatorWarpFieldEffect(u8 taskId) +static void Task_EscalatorWarpFieldEffect(u8 taskId) { struct Task * task = &gTasks[taskId]; while (sEscalatorWarpFieldEffectFuncs[task->data[0]](task)) ; } -bool8 EscalatorWarpEffect_1(struct Task * task) +static bool8 EscalatorWarpEffect_1(struct Task * task) { FreezeObjectEvents(); CameraObjectReset2(); @@ -1294,7 +1293,7 @@ bool8 EscalatorWarpEffect_1(struct Task * task) return FALSE; } -bool8 EscalatorWarpEffect_2(struct Task * task) +static bool8 EscalatorWarpEffect_2(struct Task * task) { struct ObjectEvent * objectEvent; objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -1313,7 +1312,7 @@ bool8 EscalatorWarpEffect_2(struct Task * task) return FALSE; } -bool8 EscalatorWarpEffect_3(struct Task * task) +static bool8 EscalatorWarpEffect_3(struct Task * task) { Escalator_AnimatePlayerGoingDown(task); if (task->data[2] > 3) @@ -1324,14 +1323,14 @@ bool8 EscalatorWarpEffect_3(struct Task * task) return FALSE; } -bool8 EscalatorWarpEffect_4(struct Task * task) +static bool8 EscalatorWarpEffect_4(struct Task * task) { Escalator_AnimatePlayerGoingDown(task); Escalator_TransitionToWarpInEffect(); return FALSE; } -bool8 EscalatorWarpEffect_5(struct Task * task) +static bool8 EscalatorWarpEffect_5(struct Task * task) { Escalator_AnimatePlayerGoingUp(task); if (task->data[2] > 3) @@ -1342,7 +1341,7 @@ bool8 EscalatorWarpEffect_5(struct Task * task) return FALSE; } -bool8 EscalatorWarpEffect_6(struct Task * task) +static bool8 EscalatorWarpEffect_6(struct Task * task) { Escalator_AnimatePlayerGoingUp(task); Escalator_TransitionToWarpInEffect(); @@ -1350,7 +1349,7 @@ bool8 EscalatorWarpEffect_6(struct Task * task) } -void Escalator_AnimatePlayerGoingDown(struct Task * task) +static void Escalator_AnimatePlayerGoingDown(struct Task * task) { struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; @@ -1363,7 +1362,7 @@ void Escalator_AnimatePlayerGoingDown(struct Task * task) } } -void Escalator_AnimatePlayerGoingUp(struct Task * task) +static void Escalator_AnimatePlayerGoingUp(struct Task * task) { struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; @@ -1376,13 +1375,13 @@ void Escalator_AnimatePlayerGoingUp(struct Task * task) } } -void Escalator_BeginFadeOutToNewMap(void) +static void Escalator_BeginFadeOutToNewMap(void) { TryFadeOutOldMapMusic(); WarpFadeOutScreen(); } -void Escalator_TransitionToWarpInEffect(void) +static void Escalator_TransitionToWarpInEffect(void) { if (!gPaletteFade.active && BGMusicStopped() == TRUE) { @@ -1394,7 +1393,7 @@ void Escalator_TransitionToWarpInEffect(void) } } -bool8 (*const sEscalatorWarpInFieldEffectFuncs[])(struct Task * task) = { +static bool8 (*const sEscalatorWarpInFieldEffectFuncs[])(struct Task * task) = { EscalatorWarpInEffect_1, EscalatorWarpInEffect_2, EscalatorWarpInEffect_3, @@ -1404,7 +1403,7 @@ bool8 (*const sEscalatorWarpInFieldEffectFuncs[])(struct Task * task) = { EscalatorWarpInEffect_7 }; -void FieldCB_EscalatorWarpIn(void) +static void FieldCB_EscalatorWarpIn(void) { Overworld_PlaySpecialMapMusic(); WarpFadeInScreen(); @@ -1415,14 +1414,14 @@ void FieldCB_EscalatorWarpIn(void) gFieldCallback = NULL; } -void Task_EscalatorWarpInFieldEffect(u8 taskId) +static void Task_EscalatorWarpInFieldEffect(u8 taskId) { struct Task * task = &gTasks[taskId]; while (sEscalatorWarpInFieldEffectFuncs[task->data[0]](task)) ; } -bool8 EscalatorWarpInEffect_1(struct Task * task) +static bool8 EscalatorWarpInEffect_1(struct Task * task) { struct ObjectEvent * objectEvent; s16 x; @@ -1447,7 +1446,7 @@ bool8 EscalatorWarpInEffect_1(struct Task * task) return TRUE; } -bool8 EscalatorWarpInEffect_2(struct Task * task) +static bool8 EscalatorWarpInEffect_2(struct Task * task) { struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; @@ -1457,7 +1456,7 @@ bool8 EscalatorWarpInEffect_2(struct Task * task) return FALSE; } -bool8 EscalatorWarpInEffect_3(struct Task * task) +static bool8 EscalatorWarpInEffect_3(struct Task * task) { struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; @@ -1478,7 +1477,7 @@ bool8 EscalatorWarpInEffect_3(struct Task * task) } -bool8 EscalatorWarpInEffect_4(struct Task * task) +static bool8 EscalatorWarpInEffect_4(struct Task * task) { struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; @@ -1488,7 +1487,7 @@ bool8 EscalatorWarpInEffect_4(struct Task * task) return FALSE; } -bool8 EscalatorWarpInEffect_5(struct Task * task) +static bool8 EscalatorWarpInEffect_5(struct Task * task) { struct Sprite * sprite; sprite = &gSprites[gPlayerAvatar.spriteId]; @@ -1508,7 +1507,7 @@ bool8 EscalatorWarpInEffect_5(struct Task * task) return FALSE; } -bool8 EscalatorWarpInEffect_6(struct Task * task) +static bool8 EscalatorWarpInEffect_6(struct Task * task) { if (IsEscalatorMoving()) { @@ -1519,7 +1518,7 @@ bool8 EscalatorWarpInEffect_6(struct Task * task) return TRUE; } -bool8 EscalatorWarpInEffect_7(struct Task * task) +static bool8 EscalatorWarpInEffect_7(struct Task * task) { struct ObjectEvent * objectEvent; objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -1535,15 +1534,15 @@ bool8 EscalatorWarpInEffect_7(struct Task * task) return FALSE; } -void Task_UseWaterfall(u8 taskId); +static void Task_UseWaterfall(u8 taskId); -bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj); -bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * playerObj); -bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEvent * playerObj); -bool8 waterfall_3_move_player_probably(struct Task * task, struct ObjectEvent * playerObj); -bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEvent * playerObj); +static bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj); +static bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * playerObj); +static bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEvent * playerObj); +static bool8 waterfall_3_move_player_probably(struct Task * task, struct ObjectEvent * playerObj); +static bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEvent * playerObj); -bool8 (*const sUseWaterfallFieldEffectFuncs[])(struct Task * task, struct ObjectEvent * playerObj) = { +static bool8 (*const sUseWaterfallFieldEffectFuncs[])(struct Task * task, struct ObjectEvent * playerObj) = { waterfall_0_setup, waterfall_1_do_anim_probably, waterfall_2_wait_anim_finish_probably, @@ -1559,13 +1558,13 @@ u32 FldEff_UseWaterfall(void) return 0; } -void Task_UseWaterfall(u8 taskId) +static void Task_UseWaterfall(u8 taskId) { while (sUseWaterfallFieldEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId])) ; } -bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj) +static bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj) { ScriptContext2_Enable(); gPlayerAvatar.preventStep = TRUE; @@ -1573,7 +1572,7 @@ bool8 waterfall_0_setup(struct Task * task, struct ObjectEvent * playerObj) return FALSE; } -bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * playerObj) +static bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * playerObj) { ScriptContext2_Enable(); if (!ObjectEventIsMovementOverridden(playerObj)) @@ -1586,7 +1585,7 @@ bool8 waterfall_1_do_anim_probably(struct Task * task, struct ObjectEvent * play return FALSE; } -bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEvent * playerObj) +static bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEvent * playerObj) { if (FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON)) return FALSE; @@ -1594,14 +1593,14 @@ bool8 waterfall_2_wait_anim_finish_probably(struct Task * task, struct ObjectEve return TRUE; } -bool8 waterfall_3_move_player_probably(struct Task * task, struct ObjectEvent * playerObj) +static bool8 waterfall_3_move_player_probably(struct Task * task, struct ObjectEvent * playerObj) { ObjectEventSetHeldMovement(playerObj, sub_8063F2C(DIR_NORTH)); task->data[0]++; return FALSE; } -bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEvent * playerObj) +static bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEvent * playerObj) { if (!ObjectEventClearHeldMovementIfFinished(playerObj)) return FALSE; @@ -1617,12 +1616,12 @@ bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct ObjectEve return FALSE; } -void Task_Dive(u8 taskId); -bool8 dive_1_lock(struct Task * task); -bool8 dive_2_unknown(struct Task * task); -bool8 dive_3_unknown(struct Task * task); +static void Task_Dive(u8 taskId); +static bool8 dive_1_lock(struct Task * task); +static bool8 dive_2_unknown(struct Task * task); +static bool8 dive_3_unknown(struct Task * task); -bool8 (*const sDiveFieldEffectFuncPtrs[])(struct Task * task) = { +static bool8 (*const sDiveFieldEffectFuncPtrs[])(struct Task * task) = { dive_1_lock, dive_2_unknown, dive_3_unknown @@ -1637,20 +1636,20 @@ u32 FldEff_UseDive(void) return 0; } -void Task_Dive(u8 taskId) +static void Task_Dive(u8 taskId) { while (sDiveFieldEffectFuncPtrs[gTasks[taskId].data[0]](&gTasks[taskId])) ; } -bool8 dive_1_lock(struct Task * task) +static bool8 dive_1_lock(struct Task * task) { gPlayerAvatar.preventStep = TRUE; task->data[0]++; return FALSE; } -bool8 dive_2_unknown(struct Task * task) +static bool8 dive_2_unknown(struct Task * task) { ScriptContext2_Enable(); gFieldEffectArguments[0] = task->data[15]; @@ -1659,7 +1658,7 @@ bool8 dive_2_unknown(struct Task * task) return FALSE; } -bool8 dive_3_unknown(struct Task * task) +static bool8 dive_3_unknown(struct Task * task) { struct MapPosition pos; PlayerGetDestCoords(&pos.x, &pos.y); @@ -1672,21 +1671,21 @@ bool8 dive_3_unknown(struct Task * task) return FALSE; } -void Task_LavaridgeGymB1FWarp(u8 taskId); -bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -void FieldCB_LavaridgeGymB1FWarpExit(void); -void Task_LavaridgeGymB1FWarpExit(u8 taskId); -bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); - -bool8 (*const sLavaridgeGymB1FWarpEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { +static void Task_LavaridgeGymB1FWarp(u8 taskId); +static bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static void FieldCB_LavaridgeGymB1FWarpExit(void); +static void Task_LavaridgeGymB1FWarpExit(u8 taskId); +static bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); + +static bool8 (*const sLavaridgeGymB1FWarpEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { LavaridgeGymB1FWarpEffect_1, LavaridgeGymB1FWarpEffect_2, LavaridgeGymB1FWarpEffect_3, @@ -1700,12 +1699,12 @@ void StartLavaridgeGymB1FWarp(u8 priority) CreateTask(Task_LavaridgeGymB1FWarp, priority); } -void Task_LavaridgeGymB1FWarp(u8 taskId) +static void Task_LavaridgeGymB1FWarp(u8 taskId) { while (sLavaridgeGymB1FWarpEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId])); } -bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { FreezeObjectEvents(); CameraObjectReset2(); @@ -1717,7 +1716,7 @@ bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent * objec return TRUE; } -bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { SetCameraPanning(0, task->data[1]); task->data[1] = -task->data[1]; @@ -1730,7 +1729,7 @@ bool8 LavaridgeGymB1FWarpEffect_2(struct Task * task, struct ObjectEvent * objec return FALSE; } -bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { sprite->pos2.y = 0; task->data[3] = 1; @@ -1744,7 +1743,7 @@ bool8 LavaridgeGymB1FWarpEffect_3(struct Task * task, struct ObjectEvent * objec return TRUE; } -bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { s16 centerToCornerVecY; SetCameraPanning(0, task->data[1]); @@ -1787,7 +1786,7 @@ bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent * objec return FALSE; } -bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { TryFadeOutOldMapMusic(); WarpFadeOutScreen(); @@ -1795,7 +1794,7 @@ bool8 LavaridgeGymB1FWarpEffect_5(struct Task * task, struct ObjectEvent * objec return FALSE; } -bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (!gPaletteFade.active && BGMusicStopped() == TRUE) { @@ -1807,14 +1806,14 @@ bool8 LavaridgeGymB1FWarpEffect_6(struct Task * task, struct ObjectEvent * objec return FALSE; } -bool8 (*const sLavaridgeGymB1FWarpExitEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { +static bool8 (*const sLavaridgeGymB1FWarpExitEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { LavaridgeGymB1FWarpExitEffect_1, LavaridgeGymB1FWarpExitEffect_2, LavaridgeGymB1FWarpExitEffect_3, LavaridgeGymB1FWarpExitEffect_4 }; -void FieldCB_LavaridgeGymB1FWarpExit(void) +static void FieldCB_LavaridgeGymB1FWarpExit(void) { Overworld_PlaySpecialMapMusic(); WarpFadeInScreen(); @@ -1824,12 +1823,12 @@ void FieldCB_LavaridgeGymB1FWarpExit(void) CreateTask(Task_LavaridgeGymB1FWarpExit, 0); } -void Task_LavaridgeGymB1FWarpExit(u8 taskId) +static void Task_LavaridgeGymB1FWarpExit(u8 taskId) { while (sLavaridgeGymB1FWarpExitEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId])); } -bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { CameraObjectReset2(); FreezeObjectEvents(); @@ -1839,7 +1838,7 @@ bool8 LavaridgeGymB1FWarpExitEffect_1(struct Task * task, struct ObjectEvent * o return FALSE; } -bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (IsWeatherNotFadingIn()) { @@ -1853,7 +1852,7 @@ bool8 LavaridgeGymB1FWarpExitEffect_2(struct Task * task, struct ObjectEvent * o return FALSE; } -bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { sprite = &gSprites[task->data[1]]; if (sprite->animCmdIndex > 1) @@ -1867,7 +1866,7 @@ bool8 LavaridgeGymB1FWarpExitEffect_3(struct Task * task, struct ObjectEvent * o return FALSE; } -bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (ObjectEventClearHeldMovementIfFinished(objectEvent)) { @@ -1879,14 +1878,14 @@ bool8 LavaridgeGymB1FWarpExitEffect_4(struct Task * task, struct ObjectEvent * o return FALSE; } -void Task_LavaridgeGym1FWarp(u8 taskId); -bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 LavaridgeGym1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static void Task_LavaridgeGym1FWarp(u8 taskId); +static bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); +static bool8 LavaridgeGym1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite); -bool8 (*const sLavaridgeGym1FWarpEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { +static bool8 (*const sLavaridgeGym1FWarpEffectFuncs[])(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) = { LavaridgeGym1FWarpEffect_1, LavaridgeGym1FWarpEffect_2, LavaridgeGym1FWarpEffect_3, @@ -1918,12 +1917,12 @@ void StartLavaridgeGym1FWarp(u8 priority) CreateTask(Task_LavaridgeGym1FWarp, priority); } -void Task_LavaridgeGym1FWarp(u8 taskId) +static void Task_LavaridgeGym1FWarp(u8 taskId) { while(sLavaridgeGym1FWarpEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId], &gObjectEvents[gPlayerAvatar.objectEventId], &gSprites[gPlayerAvatar.spriteId])); } -bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { FreezeObjectEvents(); CameraObjectReset2(); @@ -1933,7 +1932,7 @@ bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * object return FALSE; } -bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (ObjectEventClearHeldMovementIfFinished(objectEvent)) { @@ -1955,7 +1954,7 @@ bool8 LavaridgeGym1FWarpEffect_2(struct Task * task, struct ObjectEvent * object return FALSE; } -bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (gSprites[task->data[1]].animCmdIndex == 2) { @@ -1965,7 +1964,7 @@ bool8 LavaridgeGym1FWarpEffect_3(struct Task * task, struct ObjectEvent * object return FALSE; } -bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (!FieldEffectActiveListContains(FLDEFF_POP_OUT_OF_ASH)) { @@ -1976,7 +1975,7 @@ bool8 LavaridgeGym1FWarpEffect_4(struct Task * task, struct ObjectEvent * object return FALSE; } -bool8 LavaridgeGym1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) +static bool8 LavaridgeGym1FWarpEffect_5(struct Task * task, struct ObjectEvent * objectEvent, struct Sprite * sprite) { if (!gPaletteFade.active && BGMusicStopped() == TRUE) { @@ -2006,17 +2005,17 @@ void SpriteCB_PopOutOfAsh(struct Sprite * sprite) } } -void Task_DoEscapeRopeFieldEffect(u8 taskId); -void EscapeRopeFieldEffect_Step0(struct Task * task); -void EscapeRopeFieldEffect_Step1(struct Task * task); -u8 sub_808576C(struct ObjectEvent * playerObj, s16 *a1p, s16 *a2p); -bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *a1p, s16 *a2p); -void FieldCallback_EscapeRopeExit(void); -void Task_DoEscapeRopeExitFieldEffect(u8 taskId); -void EscapeRopeExitFieldEffect_Step0(struct Task * task); -void EscapeRopeExitFieldEffect_Step1(struct Task * task); +static void Task_DoEscapeRopeFieldEffect(u8 taskId); +static void EscapeRopeFieldEffect_Step0(struct Task * task); +static void EscapeRopeFieldEffect_Step1(struct Task * task); +static u8 sub_808576C(struct ObjectEvent * playerObj, s16 *a1p, s16 *a2p); +static bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *a1p, s16 *a2p); +static void FieldCallback_EscapeRopeExit(void); +static void Task_DoEscapeRopeExitFieldEffect(u8 taskId); +static void EscapeRopeExitFieldEffect_Step0(struct Task * task); +static void EscapeRopeExitFieldEffect_Step1(struct Task * task); -void (*const gEscapeRopeFieldEffectFuncs[])(struct Task * task) = { +static void (*const gEscapeRopeFieldEffectFuncs[])(struct Task * task) = { EscapeRopeFieldEffect_Step0, EscapeRopeFieldEffect_Step1 }; @@ -2028,12 +2027,12 @@ void StartEscapeRopeFieldEffect(void) CreateTask(Task_DoEscapeRopeFieldEffect, 80); } -void Task_DoEscapeRopeFieldEffect(u8 taskId) +static void Task_DoEscapeRopeFieldEffect(u8 taskId) { gEscapeRopeFieldEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void EscapeRopeFieldEffect_Step0(struct Task * task) +static void EscapeRopeFieldEffect_Step0(struct Task * task) { task->data[0]++; task->data[13] = 64; @@ -2041,7 +2040,7 @@ void EscapeRopeFieldEffect_Step0(struct Task * task) task->data[15] = 0; } -void EscapeRopeFieldEffect_Step1(struct Task * task) +static void EscapeRopeFieldEffect_Step1(struct Task * task) { struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; s16 *data = task->data; @@ -2071,7 +2070,7 @@ void EscapeRopeFieldEffect_Step1(struct Task * task) } } -const u8 gUnknown_83CC0E8[] = { +static const u8 gUnknown_83CC0E8[] = { [DIR_NONE] = DIR_SOUTH, [DIR_SOUTH] = DIR_WEST, [DIR_WEST] = DIR_NORTH, @@ -2079,7 +2078,7 @@ const u8 gUnknown_83CC0E8[] = { [DIR_EAST] = DIR_SOUTH, }; -u8 sub_808576C(struct ObjectEvent * playerObj, s16 *delay_p, s16 *stage_p) +static u8 sub_808576C(struct ObjectEvent * playerObj, s16 *delay_p, s16 *stage_p) { if (!ObjectEventIsMovementOverridden(playerObj) || ObjectEventClearHeldMovementIfFinished(playerObj)) { @@ -2094,7 +2093,7 @@ u8 sub_808576C(struct ObjectEvent * playerObj, s16 *delay_p, s16 *stage_p) return playerObj->facingDirection; } -bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p) +static bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p) { struct Sprite * sprite = &gSprites[playerObj->spriteId]; switch (*state_p) @@ -2130,12 +2129,12 @@ bool32 sub_80857F0(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p) return TRUE; } -void (*const sEscapeRopeExitEffectFuncs[])(struct Task * task) = { +static void (*const sEscapeRopeExitEffectFuncs[])(struct Task * task) = { EscapeRopeExitFieldEffect_Step0, EscapeRopeExitFieldEffect_Step1 }; -bool32 sub_80858A4(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p, s16 *priority_p, s16 *subpriority_p, s16 *subspriteMode_p) +static bool32 sub_80858A4(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p, s16 *priority_p, s16 *subpriority_p, s16 *subspriteMode_p) { struct Sprite * sprite = &gSprites[playerObj->spriteId]; switch (*state_p) @@ -2181,7 +2180,7 @@ bool32 sub_80858A4(struct ObjectEvent * playerObj, s16 *state_p, s16 *y_p, s16 * return TRUE; } -void FieldCallback_EscapeRopeExit(void) +static void FieldCallback_EscapeRopeExit(void) { Overworld_PlaySpecialMapMusic(); WarpFadeInScreen(); @@ -2193,12 +2192,12 @@ void FieldCallback_EscapeRopeExit(void) CreateTask(Task_DoEscapeRopeExitFieldEffect, 0); } -void Task_DoEscapeRopeExitFieldEffect(u8 taskId) +static void Task_DoEscapeRopeExitFieldEffect(u8 taskId) { sEscapeRopeExitEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void EscapeRopeExitFieldEffect_Step0(struct Task * task) +static void EscapeRopeExitFieldEffect_Step0(struct Task * task) { if (IsWeatherNotFadingIn()) { @@ -2208,7 +2207,7 @@ void EscapeRopeExitFieldEffect_Step0(struct Task * task) } } -void EscapeRopeExitFieldEffect_Step1(struct Task * task) +static void EscapeRopeExitFieldEffect_Step1(struct Task * task) { s16 *data = task->data; struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -2233,18 +2232,18 @@ void EscapeRopeExitFieldEffect_Step1(struct Task * task) } } -void Task_DoTeleportFieldEffect(u8 taskId); -void TeleportFieldEffectTask1(struct Task * task); -void TeleportFieldEffectTask2(struct Task * task); -void TeleportFieldEffectTask3(struct Task * task); -void TeleportFieldEffectTask4(struct Task * task); -void FieldCallback_TeleportIn(void); -void Task_DoTeleportInFieldEffect(u8 taskId); -void TeleportInFieldEffectTask1(struct Task * task); -void TeleportInFieldEffectTask2(struct Task * task); -void TeleportInFieldEffectTask3(struct Task * task); +static void Task_DoTeleportFieldEffect(u8 taskId); +static void TeleportFieldEffectTask1(struct Task * task); +static void TeleportFieldEffectTask2(struct Task * task); +static void TeleportFieldEffectTask3(struct Task * task); +static void TeleportFieldEffectTask4(struct Task * task); +static void FieldCallback_TeleportIn(void); +static void Task_DoTeleportInFieldEffect(u8 taskId); +static void TeleportInFieldEffectTask1(struct Task * task); +static void TeleportInFieldEffectTask2(struct Task * task); +static void TeleportInFieldEffectTask3(struct Task * task); -void (*const sTeleportEffectFuncs[])(struct Task * ) = { +static void (*const sTeleportEffectFuncs[])(struct Task * ) = { TeleportFieldEffectTask1, TeleportFieldEffectTask2, TeleportFieldEffectTask3, @@ -2256,12 +2255,12 @@ void CreateTeleportFieldEffectTask(void) CreateTask(Task_DoTeleportFieldEffect, 0); } -void Task_DoTeleportFieldEffect(u8 taskId) +static void Task_DoTeleportFieldEffect(u8 taskId) { sTeleportEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void TeleportFieldEffectTask1(struct Task * task) +static void TeleportFieldEffectTask1(struct Task * task) { ScriptContext2_Enable(); FreezeObjectEvents(); @@ -2270,7 +2269,7 @@ void TeleportFieldEffectTask1(struct Task * task) task->data[0]++; } -void TeleportFieldEffectTask2(struct Task * task) +static void TeleportFieldEffectTask2(struct Task * task) { u8 spinDirections[5] = { [DIR_NONE] = DIR_SOUTH, @@ -2296,7 +2295,7 @@ void TeleportFieldEffectTask2(struct Task * task) } } -void TeleportFieldEffectTask3(struct Task * task) +static void TeleportFieldEffectTask3(struct Task * task) { u8 spinDirections[5] = {DIR_SOUTH, DIR_WEST, DIR_EAST, DIR_NORTH, DIR_SOUTH}; struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -2324,7 +2323,7 @@ void TeleportFieldEffectTask3(struct Task * task) } } -void TeleportFieldEffectTask4(struct Task * task) +static void TeleportFieldEffectTask4(struct Task * task) { if (!gPaletteFade.active) { @@ -2339,13 +2338,13 @@ void TeleportFieldEffectTask4(struct Task * task) } } -void (*const sTeleportInEffectFuncs[])(struct Task * ) = { +static void (*const sTeleportInEffectFuncs[])(struct Task * ) = { TeleportInFieldEffectTask1, TeleportInFieldEffectTask2, TeleportInFieldEffectTask3 }; -void FieldCallback_TeleportIn(void) +static void FieldCallback_TeleportIn(void) { Overworld_PlaySpecialMapMusic(); WarpFadeInScreen(); @@ -2358,12 +2357,12 @@ void FieldCallback_TeleportIn(void) CreateTask(Task_DoTeleportInFieldEffect, 0); } -void Task_DoTeleportInFieldEffect(u8 taskId) +static void Task_DoTeleportInFieldEffect(u8 taskId) { sTeleportInEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void TeleportInFieldEffectTask1(struct Task * task) +static void TeleportInFieldEffectTask1(struct Task * task) { struct Sprite * sprite; s16 centerToCornerVecY; @@ -2382,7 +2381,7 @@ void TeleportInFieldEffectTask1(struct Task * task) } } -void TeleportInFieldEffectTask2(struct Task * task) +static void TeleportInFieldEffectTask2(struct Task * task) { u8 spinDirections[5] = {1, 3, 4, 2, 1}; struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -2421,7 +2420,7 @@ void TeleportInFieldEffectTask2(struct Task * task) } } -void TeleportInFieldEffectTask3(struct Task * task) +static void TeleportInFieldEffectTask3(struct Task * task) { u8 spinDirections[5] = {1, 3, 4, 2, 1}; struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -2439,34 +2438,34 @@ void TeleportInFieldEffectTask3(struct Task * task) } } -void Task_ShowMon_Outdoors(u8 taskId); -void ShowMonEffect_Outdoors_1(struct Task * task); -void ShowMonEffect_Outdoors_2(struct Task * task); -void ShowMonEffect_Outdoors_3(struct Task * task); -void ShowMonEffect_Outdoors_4(struct Task * task); -void ShowMonEffect_Outdoors_5(struct Task * task); -void ShowMonEffect_Outdoors_6(struct Task * task); -void ShowMonEffect_Outdoors_7(struct Task * task); -void VBlankCB_ShowMonEffect_Outdoors(void); -void LoadFieldMoveStreaksTilemapToVram(u16 screenbase); -void Task_ShowMon_Indoors(u8 taskId); -void ShowMonEffect_Indoors_1(struct Task * task); -void ShowMonEffect_Indoors_2(struct Task * task); -void ShowMonEffect_Indoors_3(struct Task * task); -void ShowMonEffect_Indoors_4(struct Task * task); -void ShowMonEffect_Indoors_5(struct Task * task); -void ShowMonEffect_Indoors_6(struct Task * task); -void ShowMonEffect_Indoors_7(struct Task * task); -void VBlankCB_ShowMonEffect_Indoors(void); -void sub_8086728(struct Task * task); -bool8 sub_8086738(struct Task * task); -bool8 sub_80867F0(struct Task * task); -u8 sub_8086860(u32 species, u32 otId, u32 personality); -void sub_80868C0(struct Sprite * sprite); -void sub_8086904(struct Sprite * sprite); -void sub_8086920(struct Sprite * sprite); - -void (*const sShowMonOutdoorsEffectFuncs[])(struct Task * task) = { +static void Task_ShowMon_Outdoors(u8 taskId); +static void ShowMonEffect_Outdoors_1(struct Task * task); +static void ShowMonEffect_Outdoors_2(struct Task * task); +static void ShowMonEffect_Outdoors_3(struct Task * task); +static void ShowMonEffect_Outdoors_4(struct Task * task); +static void ShowMonEffect_Outdoors_5(struct Task * task); +static void ShowMonEffect_Outdoors_6(struct Task * task); +static void ShowMonEffect_Outdoors_7(struct Task * task); +static void VBlankCB_ShowMonEffect_Outdoors(void); +static void LoadFieldMoveStreaksTilemapToVram(u16 screenbase); +static void Task_ShowMon_Indoors(u8 taskId); +static void ShowMonEffect_Indoors_1(struct Task * task); +static void ShowMonEffect_Indoors_2(struct Task * task); +static void ShowMonEffect_Indoors_3(struct Task * task); +static void ShowMonEffect_Indoors_4(struct Task * task); +static void ShowMonEffect_Indoors_5(struct Task * task); +static void ShowMonEffect_Indoors_6(struct Task * task); +static void ShowMonEffect_Indoors_7(struct Task * task); +static void VBlankCB_ShowMonEffect_Indoors(void); +static void sub_8086728(struct Task * task); +static bool8 sub_8086738(struct Task * task); +static bool8 sub_80867F0(struct Task * task); +static u8 sub_8086860(u32 species, u32 otId, u32 personality); +static void sub_80868C0(struct Sprite * sprite); +static void sub_8086904(struct Sprite * sprite); +static void sub_8086920(struct Sprite * sprite); + +static void (*const sShowMonOutdoorsEffectFuncs[])(struct Task * task) = { ShowMonEffect_Outdoors_1, ShowMonEffect_Outdoors_2, ShowMonEffect_Outdoors_3, @@ -2500,12 +2499,12 @@ u32 FldEff_FieldMoveShowMonInit(void) return 0; } -void Task_ShowMon_Outdoors(u8 taskId) +static void Task_ShowMon_Outdoors(u8 taskId) { sShowMonOutdoorsEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void ShowMonEffect_Outdoors_1(struct Task * task) +static void ShowMonEffect_Outdoors_1(struct Task * task) { task->data[11] = GetGpuReg(REG_OFFSET_WININ); task->data[12] = GetGpuReg(REG_OFFSET_WINOUT); @@ -2522,7 +2521,7 @@ void ShowMonEffect_Outdoors_1(struct Task * task) task->data[0]++; } -void ShowMonEffect_Outdoors_2(struct Task * task) +static void ShowMonEffect_Outdoors_2(struct Task * task) { u16 charbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 2) << 14); u16 screenbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11); @@ -2533,7 +2532,7 @@ void ShowMonEffect_Outdoors_2(struct Task * task) task->data[0]++; } -void ShowMonEffect_Outdoors_3(struct Task * task) +static void ShowMonEffect_Outdoors_3(struct Task * task) { s16 v0; s16 v2; @@ -2566,7 +2565,7 @@ void ShowMonEffect_Outdoors_3(struct Task * task) } } -void ShowMonEffect_Outdoors_4(struct Task * task) +static void ShowMonEffect_Outdoors_4(struct Task * task) { task->data[5] -= 16; if (gSprites[task->data[15]].data[7]) @@ -2575,7 +2574,7 @@ void ShowMonEffect_Outdoors_4(struct Task * task) } } -void ShowMonEffect_Outdoors_5(struct Task * task) +static void ShowMonEffect_Outdoors_5(struct Task * task) { s16 v2; s16 v3; @@ -2599,7 +2598,7 @@ void ShowMonEffect_Outdoors_5(struct Task * task) } } -void ShowMonEffect_Outdoors_6(struct Task * task) +static void ShowMonEffect_Outdoors_6(struct Task * task) { u16 bg0cnt = (GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11; CpuFill32(0, (void *)VRAM + bg0cnt, 0x800); @@ -2610,7 +2609,7 @@ void ShowMonEffect_Outdoors_6(struct Task * task) task->data[0]++; } -void ShowMonEffect_Outdoors_7(struct Task * task) +static void ShowMonEffect_Outdoors_7(struct Task * task) { IntrCallback callback; LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&callback); @@ -2623,7 +2622,7 @@ void ShowMonEffect_Outdoors_7(struct Task * task) DestroyTask(FindTaskIdByFunc(Task_ShowMon_Outdoors)); } -void VBlankCB_ShowMonEffect_Outdoors(void) +static void VBlankCB_ShowMonEffect_Outdoors(void) { IntrCallback callback; struct Task * task = &gTasks[FindTaskIdByFunc(Task_ShowMon_Outdoors)]; @@ -2637,7 +2636,7 @@ void VBlankCB_ShowMonEffect_Outdoors(void) SetGpuReg(REG_OFFSET_BG0VOFS, task->data[6]); } -void LoadFieldMoveStreaksTilemapToVram(u16 screenbase) +static void LoadFieldMoveStreaksTilemapToVram(u16 screenbase) { u16 i; u16 *dest; @@ -2648,7 +2647,7 @@ void LoadFieldMoveStreaksTilemapToVram(u16 screenbase) } } -void (*const sShowMonIndoorsEffectFuncs[])(struct Task * ) = { +static void (*const sShowMonIndoorsEffectFuncs[])(struct Task * ) = { ShowMonEffect_Indoors_1, ShowMonEffect_Indoors_2, ShowMonEffect_Indoors_3, @@ -2658,12 +2657,12 @@ void (*const sShowMonIndoorsEffectFuncs[])(struct Task * ) = { ShowMonEffect_Indoors_7 }; -void Task_ShowMon_Indoors(u8 taskId) +static void Task_ShowMon_Indoors(u8 taskId) { sShowMonIndoorsEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void ShowMonEffect_Indoors_1(struct Task * task) +static void ShowMonEffect_Indoors_1(struct Task * task) { SetGpuReg(REG_OFFSET_BG0HOFS, task->data[1]); SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]); @@ -2672,7 +2671,7 @@ void ShowMonEffect_Indoors_1(struct Task * task) task->data[0]++; } -void ShowMonEffect_Indoors_2(struct Task * task) +static void ShowMonEffect_Indoors_2(struct Task * task) { u16 charbase; u16 screenbase; @@ -2685,7 +2684,7 @@ void ShowMonEffect_Indoors_2(struct Task * task) task->data[0]++; } -void ShowMonEffect_Indoors_3(struct Task * task) +static void ShowMonEffect_Indoors_3(struct Task * task) { if (sub_8086738(task)) { @@ -2699,7 +2698,7 @@ void ShowMonEffect_Indoors_3(struct Task * task) sub_8086728(task); } -void ShowMonEffect_Indoors_4(struct Task * task) +static void ShowMonEffect_Indoors_4(struct Task * task) { sub_8086728(task); if (gSprites[task->data[15]].data[7]) @@ -2708,7 +2707,7 @@ void ShowMonEffect_Indoors_4(struct Task * task) } } -void ShowMonEffect_Indoors_5(struct Task * task) +static void ShowMonEffect_Indoors_5(struct Task * task) { sub_8086728(task); task->data[3] = task->data[1] & 7; @@ -2719,7 +2718,7 @@ void ShowMonEffect_Indoors_5(struct Task * task) task->data[0]++; } -void ShowMonEffect_Indoors_6(struct Task * task) +static void ShowMonEffect_Indoors_6(struct Task * task) { sub_8086728(task); if (sub_80867F0(task)) @@ -2728,7 +2727,7 @@ void ShowMonEffect_Indoors_6(struct Task * task) } } -void ShowMonEffect_Indoors_7(struct Task * task) +static void ShowMonEffect_Indoors_7(struct Task * task) { IntrCallback intrCallback; u16 charbase; @@ -2744,7 +2743,7 @@ void ShowMonEffect_Indoors_7(struct Task * task) DestroyTask(FindTaskIdByFunc(Task_ShowMon_Indoors)); } -void VBlankCB_ShowMonEffect_Indoors(void) +static void VBlankCB_ShowMonEffect_Indoors(void) { IntrCallback intrCallback; struct Task * task; @@ -2755,13 +2754,13 @@ void VBlankCB_ShowMonEffect_Indoors(void) SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]); } -void sub_8086728(struct Task * task) +static void sub_8086728(struct Task * task) { task->data[1] -= 16; task->data[3] += 16; } -bool8 sub_8086738(struct Task * task) +static bool8 sub_8086738(struct Task * task) { u16 i; u16 srcOffs; @@ -2790,7 +2789,7 @@ bool8 sub_8086738(struct Task * task) return FALSE; } -bool8 sub_80867F0(struct Task * task) +static bool8 sub_80867F0(struct Task * task) { u16 i; u16 dstOffs; @@ -2814,7 +2813,7 @@ bool8 sub_80867F0(struct Task * task) return FALSE; } -u8 sub_8086860(u32 species, u32 otId, u32 personality) +static u8 sub_8086860(u32 species, u32 otId, u32 personality) { bool16 playCry; u8 monSprite; @@ -2830,7 +2829,7 @@ u8 sub_8086860(u32 species, u32 otId, u32 personality) return monSprite; } -void sub_80868C0(struct Sprite * sprite) +static void sub_80868C0(struct Sprite * sprite) { if ((sprite->pos1.x -= 20) <= 0x78) { @@ -2848,7 +2847,7 @@ void sub_80868C0(struct Sprite * sprite) } } -void sub_8086904(struct Sprite * sprite) +static void sub_8086904(struct Sprite * sprite) { if ((--sprite->data[1]) == 0) { @@ -2856,7 +2855,7 @@ void sub_8086904(struct Sprite * sprite) } } -void sub_8086920(struct Sprite * sprite) +static void sub_8086920(struct Sprite * sprite) { if (sprite->pos1.x < -0x40) { @@ -2868,14 +2867,14 @@ void sub_8086920(struct Sprite * sprite) } } -void Task_FldEffUseSurf(u8 taskId); -void UseSurfEffect_1(struct Task * task); -void UseSurfEffect_2(struct Task * task); -void UseSurfEffect_3(struct Task * task); -void UseSurfEffect_4(struct Task * task); -void UseSurfEffect_5(struct Task * task); +static void Task_FldEffUseSurf(u8 taskId); +static void UseSurfEffect_1(struct Task * task); +static void UseSurfEffect_2(struct Task * task); +static void UseSurfEffect_3(struct Task * task); +static void UseSurfEffect_4(struct Task * task); +static void UseSurfEffect_5(struct Task * task); -void (*const sUseSurfEffectFuncs[])(struct Task * ) = { +static void (*const sUseSurfEffectFuncs[])(struct Task * ) = { UseSurfEffect_1, UseSurfEffect_2, UseSurfEffect_3, @@ -2893,12 +2892,12 @@ u8 FldEff_UseSurf(void) return FALSE; } -void Task_FldEffUseSurf(u8 taskId) +static void Task_FldEffUseSurf(u8 taskId) { sUseSurfEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void UseSurfEffect_1(struct Task * task) +static void UseSurfEffect_1(struct Task * task) { ScriptContext2_Enable(); FreezeObjectEvents(); @@ -2909,7 +2908,7 @@ void UseSurfEffect_1(struct Task * task) task->data[0]++; } -void UseSurfEffect_2(struct Task * task) +static void UseSurfEffect_2(struct Task * task) { struct ObjectEvent * objectEvent; objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -2921,7 +2920,7 @@ void UseSurfEffect_2(struct Task * task) } } -void UseSurfEffect_3(struct Task * task) +static void UseSurfEffect_3(struct Task * task) { struct ObjectEvent * objectEvent; objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -2933,7 +2932,7 @@ void UseSurfEffect_3(struct Task * task) } } -void UseSurfEffect_4(struct Task * task) +static void UseSurfEffect_4(struct Task * task) { struct ObjectEvent * objectEvent; if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON)) @@ -2950,7 +2949,7 @@ void UseSurfEffect_4(struct Task * task) } } -void UseSurfEffect_5(struct Task * task) +static void UseSurfEffect_5(struct Task * task) { struct ObjectEvent * objectEvent; objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -2968,13 +2967,13 @@ void UseSurfEffect_5(struct Task * task) } } -void Task_FldEffUseVsSeeker(u8 taskId); -void UseVsSeekerEffect_1(struct Task * task); -void UseVsSeekerEffect_2(struct Task * task); -void UseVsSeekerEffect_3(struct Task * task); -void UseVsSeekerEffect_4(struct Task * task); +static void Task_FldEffUseVsSeeker(u8 taskId); +static void UseVsSeekerEffect_1(struct Task * task); +static void UseVsSeekerEffect_2(struct Task * task); +static void UseVsSeekerEffect_3(struct Task * task); +static void UseVsSeekerEffect_4(struct Task * task); -void (*const sUseVsSeekerEffectFuncs[])(struct Task * task) = { +static void (*const sUseVsSeekerEffectFuncs[])(struct Task * task) = { UseVsSeekerEffect_1, UseVsSeekerEffect_2, UseVsSeekerEffect_3, @@ -2989,12 +2988,12 @@ u32 FldEff_UseVsSeeker(void) return 0; } -void Task_FldEffUseVsSeeker(u8 taskId) +static void Task_FldEffUseVsSeeker(u8 taskId) { sUseVsSeekerEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void UseVsSeekerEffect_1(struct Task * task) +static void UseVsSeekerEffect_1(struct Task * task) { ScriptContext2_Enable(); FreezeObjectEvents(); @@ -3002,7 +3001,7 @@ void UseVsSeekerEffect_1(struct Task * task) task->data[0]++; } -void UseVsSeekerEffect_2(struct Task * task) +static void UseVsSeekerEffect_2(struct Task * task) { struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; if (!ObjectEventIsMovementOverridden(playerObj) || ObjectEventClearHeldMovementIfFinished(playerObj)) @@ -3013,7 +3012,7 @@ void UseVsSeekerEffect_2(struct Task * task) } } -void UseVsSeekerEffect_3(struct Task * task) +static void UseVsSeekerEffect_3(struct Task * task) { struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; if (ObjectEventClearHeldMovementIfFinished(playerObj)) @@ -3029,7 +3028,7 @@ void UseVsSeekerEffect_3(struct Task * task) } } -void UseVsSeekerEffect_4(struct Task * task) +static void UseVsSeekerEffect_4(struct Task * task) { struct ObjectEvent * playerObj = &gObjectEvents[gPlayerAvatar.objectEventId]; if (ObjectEventClearHeldMovementIfFinished(playerObj)) @@ -3040,7 +3039,7 @@ void UseVsSeekerEffect_4(struct Task * task) } } -void sub_8086D94(struct Sprite * sprite); +static void sub_8086D94(struct Sprite * sprite); u8 FldEff_NpcFlyOut(void) { @@ -3055,7 +3054,7 @@ u8 FldEff_NpcFlyOut(void) return spriteId; } -void sub_8086D94(struct Sprite * sprite) +static void sub_8086D94(struct Sprite * sprite) { struct Sprite * npcSprite; @@ -3077,26 +3076,26 @@ void sub_8086D94(struct Sprite * sprite) } } -void Task_UseFly(u8 taskId); -void UseFlyEffect_1(struct Task * task); -void UseFlyEffect_2(struct Task * task); -void UseFlyEffect_3(struct Task * task); -void UseFlyEffect_4(struct Task * task); -void UseFlyEffect_5(struct Task * task); -void UseFlyEffect_6(struct Task * task); -void UseFlyEffect_7(struct Task * task); -void UseFlyEffect_8(struct Task * task); -void UseFlyEffect_9(struct Task * task); -u8 sub_8087168(void); -bool8 sub_80871AC(u8 flyBlobSpriteId); -void sub_80871C8(u8 flyBlobSpriteId); -void sub_8087204(u8 flyBlobSpriteId, u8 playerSpriteId); -void sub_8087220(struct Sprite * sprite); -void sub_80872F0(struct Sprite * sprite); -void sub_80877FC(struct Sprite * sprite, u8 affineAnimId); -void sub_8087828(struct Sprite * sprite); - -void (*const sUseFlyEffectFuncs[])(struct Task * ) = { +static void Task_UseFly(u8 taskId); +static void UseFlyEffect_1(struct Task * task); +static void UseFlyEffect_2(struct Task * task); +static void UseFlyEffect_3(struct Task * task); +static void UseFlyEffect_4(struct Task * task); +static void UseFlyEffect_5(struct Task * task); +static void UseFlyEffect_6(struct Task * task); +static void UseFlyEffect_7(struct Task * task); +static void UseFlyEffect_8(struct Task * task); +static void UseFlyEffect_9(struct Task * task); +static u8 sub_8087168(void); +static bool8 sub_80871AC(u8 flyBlobSpriteId); +static void sub_80871C8(u8 flyBlobSpriteId); +static void sub_8087204(u8 flyBlobSpriteId, u8 playerSpriteId); +static void sub_8087220(struct Sprite * sprite); +static void sub_80872F0(struct Sprite * sprite); +static void sub_80877FC(struct Sprite * sprite, u8 affineAnimId); +static void sub_8087828(struct Sprite * sprite); + +static void (*const sUseFlyEffectFuncs[])(struct Task * ) = { UseFlyEffect_1, UseFlyEffect_2, UseFlyEffect_3, @@ -3115,12 +3114,12 @@ u8 FldEff_UseFly(void) return 0; } -void Task_UseFly(u8 taskId) +static void Task_UseFly(u8 taskId) { sUseFlyEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void UseFlyEffect_1(struct Task * task) +static void UseFlyEffect_1(struct Task * task) { struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; if (!ObjectEventIsMovementOverridden(objectEvent) || ObjectEventClearHeldMovementIfFinished(objectEvent)) @@ -3134,7 +3133,7 @@ void UseFlyEffect_1(struct Task * task) } } -void UseFlyEffect_2(struct Task * task) +static void UseFlyEffect_2(struct Task * task) { struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; if (ObjectEventClearHeldMovementIfFinished(objectEvent)) @@ -3145,7 +3144,7 @@ void UseFlyEffect_2(struct Task * task) } } -void UseFlyEffect_3(struct Task * task) +static void UseFlyEffect_3(struct Task * task) { if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON)) { @@ -3160,7 +3159,7 @@ void UseFlyEffect_3(struct Task * task) } } -void UseFlyEffect_4(struct Task * task) +static void UseFlyEffect_4(struct Task * task) { if (sub_80871AC(task->data[1])) { @@ -3171,7 +3170,7 @@ void UseFlyEffect_4(struct Task * task) } } -void UseFlyEffect_5(struct Task * task) +static void UseFlyEffect_5(struct Task * task) { struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; if ((task->data[2] == 0 || (--task->data[2]) == 0) && ObjectEventClearHeldMovementIfFinished(objectEvent)) @@ -3182,7 +3181,7 @@ void UseFlyEffect_5(struct Task * task) } } -void UseFlyEffect_6(struct Task * task) +static void UseFlyEffect_6(struct Task * task) { if ((++task->data[2]) >= 8) { @@ -3196,7 +3195,7 @@ void UseFlyEffect_6(struct Task * task) } } -void UseFlyEffect_7(struct Task * task) +static void UseFlyEffect_7(struct Task * task) { if ((++task->data[2]) >= 10) { @@ -3213,7 +3212,7 @@ void UseFlyEffect_7(struct Task * task) } } -void UseFlyEffect_8(struct Task * task) +static void UseFlyEffect_8(struct Task * task) { if (sub_80871AC(task->data[1])) { @@ -3222,7 +3221,7 @@ void UseFlyEffect_8(struct Task * task) } } -void UseFlyEffect_9(struct Task * task) +static void UseFlyEffect_9(struct Task * task) { if (!gPaletteFade.active) { @@ -3231,7 +3230,7 @@ void UseFlyEffect_9(struct Task * task) } } -u8 sub_8087168(void) +static u8 sub_8087168(void) { u8 spriteId; struct Sprite * sprite; @@ -3243,12 +3242,12 @@ u8 sub_8087168(void) return spriteId; } -u8 sub_80871AC(u8 spriteId) +static u8 sub_80871AC(u8 spriteId) { return gSprites[spriteId].data[7]; } -void sub_80871C8(u8 spriteId) +static void sub_80871C8(u8 spriteId) { struct Sprite * sprite; sprite = &gSprites[spriteId]; @@ -3261,29 +3260,29 @@ void sub_80871C8(u8 spriteId) sprite->data[6] = 0x40; } -void sub_8087204(u8 a0, u8 a1) +static void sub_8087204(u8 a0, u8 a1) { gSprites[a0].data[6] = a1; } -const union AffineAnimCmd gUnknown_83CC19C[] = { +static const union AffineAnimCmd gUnknown_83CC19C[] = { AFFINEANIMCMD_FRAME( 8, 8, 226, 0), AFFINEANIMCMD_FRAME(28, 28, 0, 30), AFFINEANIMCMD_END }; -const union AffineAnimCmd gUnknown_83CC1B4[] = { +static const union AffineAnimCmd gUnknown_83CC1B4[] = { AFFINEANIMCMD_FRAME(256, 256, 64, 0), AFFINEANIMCMD_FRAME(-10, -10, 0, 22), AFFINEANIMCMD_END }; -const union AffineAnimCmd *const gUnknown_83CC1CC[] = { +static const union AffineAnimCmd *const gUnknown_83CC1CC[] = { gUnknown_83CC19C, gUnknown_83CC1B4 }; -void sub_8087220(struct Sprite * sprite) +static void sub_8087220(struct Sprite * sprite) { if (sprite->data[7] == 0) { @@ -3319,7 +3318,7 @@ void sub_8087220(struct Sprite * sprite) } } -void sub_80872F0(struct Sprite * sprite) +static void sub_80872F0(struct Sprite * sprite) { sprite->pos2.x = Cos(sprite->data[2], 0x8c); sprite->pos2.y = Sin(sprite->data[2], 0x48); @@ -3339,7 +3338,7 @@ void sub_80872F0(struct Sprite * sprite) } } -void sub_8087364(struct Sprite * sprite) +static void sub_8087364(struct Sprite * sprite) { if (sprite->data[7] == 0) { @@ -3386,23 +3385,23 @@ void sub_8087364(struct Sprite * sprite) } } -void sub_8087458(u8 spriteId) +static void sub_8087458(u8 spriteId) { sub_80871C8(spriteId); gSprites[spriteId].callback = sub_8087364; } -void Task_FldEffFlyIn(u8 taskId); -void FlyInEffect_1(struct Task * task); -void FlyInEffect_2(struct Task * task); -void FlyInEffect_3(struct Task * task); -void FlyInEffect_4(struct Task * task); -void FlyInEffect_5(struct Task * task); -void FlyInEffect_6(struct Task * task); -void FlyInEffect_7(struct Task * task); -void sub_80878C0(struct Sprite * sprite); +static void Task_FldEffFlyIn(u8 taskId); +static void FlyInEffect_1(struct Task * task); +static void FlyInEffect_2(struct Task * task); +static void FlyInEffect_3(struct Task * task); +static void FlyInEffect_4(struct Task * task); +static void FlyInEffect_5(struct Task * task); +static void FlyInEffect_6(struct Task * task); +static void FlyInEffect_7(struct Task * task); +static void sub_80878C0(struct Sprite * sprite); -void (*const sFlyInEffectFuncs[])(struct Task * task) = { +static void (*const sFlyInEffectFuncs[])(struct Task * task) = { FlyInEffect_1, FlyInEffect_2, FlyInEffect_3, @@ -3418,12 +3417,12 @@ u32 FldEff_FlyIn(void) return 0; } -void Task_FldEffFlyIn(u8 taskId) +static void Task_FldEffFlyIn(u8 taskId) { sFlyInEffectFuncs[gTasks[taskId].data[0]](&gTasks[taskId]); } -void FlyInEffect_1(struct Task * task) +static void FlyInEffect_1(struct Task * task) { struct ObjectEvent * objectEvent; objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; @@ -3452,7 +3451,7 @@ void FlyInEffect_1(struct Task * task) } } -void FlyInEffect_2(struct Task * task) +static void FlyInEffect_2(struct Task * task) { struct ObjectEvent * objectEvent; struct Sprite * sprite; @@ -3471,7 +3470,7 @@ void FlyInEffect_2(struct Task * task) } } -void FlyInEffect_3(struct Task * task) +static void FlyInEffect_3(struct Task * task) { s16 gUnknown_83CC1F0[18] = { -2, @@ -3501,7 +3500,7 @@ void FlyInEffect_3(struct Task * task) } } -void FlyInEffect_4(struct Task * task) +static void FlyInEffect_4(struct Task * task) { struct ObjectEvent * objectEvent; struct Sprite * sprite; @@ -3520,7 +3519,7 @@ void FlyInEffect_4(struct Task * task) } } -void FlyInEffect_5(struct Task * task) +static void FlyInEffect_5(struct Task * task) { if (ObjectEventClearHeldMovementIfFinished(&gObjectEvents[gPlayerAvatar.objectEventId])) { @@ -3529,7 +3528,7 @@ void FlyInEffect_5(struct Task * task) } } -void FlyInEffect_6(struct Task * task) +static void FlyInEffect_6(struct Task * task) { if (sub_80871AC(task->data[1])) { @@ -3539,7 +3538,7 @@ void FlyInEffect_6(struct Task * task) } } -void FlyInEffect_7(struct Task * task) +static void FlyInEffect_7(struct Task * task) { u8 state; struct ObjectEvent * objectEvent; @@ -3561,23 +3560,23 @@ void FlyInEffect_7(struct Task * task) } } -const union AffineAnimCmd gUnknown_83CC214[] = { +static const union AffineAnimCmd gUnknown_83CC214[] = { AFFINEANIMCMD_FRAME(24, 24, 0, 1), AFFINEANIMCMD_JUMP(0) }; -const union AffineAnimCmd gUnknown_83CC224[] = { +static const union AffineAnimCmd gUnknown_83CC224[] = { AFFINEANIMCMD_FRAME(512, 512, 0, 1), AFFINEANIMCMD_FRAME(-16, -16, 0, 1), AFFINEANIMCMD_JUMP(1) }; -const union AffineAnimCmd *const gUnknown_83CC23C[] = { +static const union AffineAnimCmd *const gUnknown_83CC23C[] = { gUnknown_83CC214, gUnknown_83CC224 }; -void sub_80877FC(struct Sprite * sprite, u8 affineAnimId) +static void sub_80877FC(struct Sprite * sprite, u8 affineAnimId) { sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; sprite->affineAnims = gUnknown_83CC23C; @@ -3585,7 +3584,7 @@ void sub_80877FC(struct Sprite * sprite, u8 affineAnimId) StartSpriteAffineAnim(sprite, affineAnimId); } -void sub_8087828(struct Sprite * sprite) +static void sub_8087828(struct Sprite * sprite) { struct Sprite * sprite2; sprite->pos2.x = Cos(sprite->data[2], 0xB4); @@ -3610,7 +3609,7 @@ void sub_8087828(struct Sprite * sprite) } } -void sub_80878C0(struct Sprite * sprite) +static void sub_80878C0(struct Sprite * sprite) { if (sprite->oam.affineMode != ST_OAM_AFFINE_OFF) { @@ -3625,9 +3624,9 @@ void sub_80878C0(struct Sprite * sprite) } } -void Task_MoveDeoxysRock_Step(u8 taskId); +static void Task_MoveDeoxysRock_Step(u8 taskId); -u32 Fldeff_MoveDeoxysRock(void) +u32 FldEff_MoveDeoxysRock(void) { u8 taskId; u8 objectEventIdBuffer; @@ -3652,7 +3651,7 @@ u32 Fldeff_MoveDeoxysRock(void) return FALSE; } -void Task_MoveDeoxysRock_Step(u8 taskId) +static void Task_MoveDeoxysRock_Step(u8 taskId) { s16 *data = gTasks[taskId].data; struct Sprite * sprite = &gSprites[data[1]]; @@ -3689,54 +3688,54 @@ void Task_MoveDeoxysRock_Step(u8 taskId) } } -void Task_FldEffUnk44(u8 taskId); -void Unk44Effect_0(s16 *data, u8 taskId); -void Unk44Effect_1(s16 *data, u8 taskId); -void Unk44Effect_2(s16 *data, u8 taskId); -void sub_8087CFC(struct Sprite * sprite); -void SpriteCB_FldEffUnk44(struct Sprite * sprite); +static void Task_FldEffUnk44(u8 taskId); +static void Unk44Effect_0(s16 *data, u8 taskId); +static void Unk44Effect_1(s16 *data, u8 taskId); +static void Unk44Effect_2(s16 *data, u8 taskId); +static void sub_8087CFC(struct Sprite * sprite); +static void SpriteCB_FldEffUnk44(struct Sprite * sprite); -void (*const sUnk44EffectFuncs[])(s16 *data, u8 taskId) = { +static void (*const sUnk44EffectFuncs[])(s16 *data, u8 taskId) = { Unk44Effect_0, Unk44Effect_1, Unk44Effect_2 }; -const struct SpriteFrameImage sImages_FldEffUnk44[] = { +static const struct SpriteFrameImage sImages_FldEffUnk44[] = { {sFldEffUnk44_Tiles + 0x00, 0x20}, {sFldEffUnk44_Tiles + 0x10, 0x20}, {sFldEffUnk44_Tiles + 0x20, 0x20}, {sFldEffUnk44_Tiles + 0x30, 0x20} }; -const union AnimCmd sAnimCmd_FldEffUnk44_0[] = { +static const union AnimCmd sAnimCmd_FldEffUnk44_0[] = { ANIMCMD_FRAME(0, 0), ANIMCMD_END }; -const union AnimCmd sAnimCmd_FldEffUnk44_1[] = { +static const union AnimCmd sAnimCmd_FldEffUnk44_1[] = { ANIMCMD_FRAME(1, 0), ANIMCMD_END }; -const union AnimCmd sAnimCmd_FldEffUnk44_2[] = { +static const union AnimCmd sAnimCmd_FldEffUnk44_2[] = { ANIMCMD_FRAME(2, 0), ANIMCMD_END }; -const union AnimCmd sAnimCmd_FldEffUnk44_3[] = { +static const union AnimCmd sAnimCmd_FldEffUnk44_3[] = { ANIMCMD_FRAME(3, 0), ANIMCMD_END }; -const union AnimCmd *const sAnimCmdTable_FldEffUnk44[] = { +static const union AnimCmd *const sAnimCmdTable_FldEffUnk44[] = { sAnimCmd_FldEffUnk44_0, sAnimCmd_FldEffUnk44_1, sAnimCmd_FldEffUnk44_2, sAnimCmd_FldEffUnk44_3 }; -const struct SpriteTemplate gUnknown_83CC2A0 = { +static const struct SpriteTemplate gUnknown_83CC2A0 = { .tileTag = 0xFFFF, .paletteTag = 4371, .oam = &sOamData_8x8, @@ -3765,7 +3764,7 @@ u32 FldEff_Unk44(void) return FALSE; } -void sub_8087B14(u8 taskId) +static void sub_8087B14(u8 taskId) { s16 *data = gTasks[taskId].data; if (data[7] != 0) @@ -3799,12 +3798,12 @@ void sub_8087B14(u8 taskId) DestroyTask(taskId); } -void sub_8087BA8(u8 taskId) +static void sub_8087BA8(u8 taskId) { gTasks[taskId].data[7] = 1; } -void Task_FldEffUnk44(u8 taskId) +static void Task_FldEffUnk44(u8 taskId) { s16 *data = gTasks[taskId].data; InstallCameraPanAheadCallback(); @@ -3812,7 +3811,7 @@ void Task_FldEffUnk44(u8 taskId) sUnk44EffectFuncs[data[1]](data, taskId); } -void Unk44Effect_0(s16 *data, u8 taskId) +static void Unk44Effect_0(s16 *data, u8 taskId) { u8 newTaskId = CreateTask(sub_8087B14, 90); PlaySE(SE_T_KAMI2); @@ -3820,7 +3819,7 @@ void Unk44Effect_0(s16 *data, u8 taskId) data[1]++; } -void Unk44Effect_1(s16 *data, u8 taskId) +static void Unk44Effect_1(s16 *data, u8 taskId) { if (++data[3] > 0x78) { @@ -3836,7 +3835,7 @@ void Unk44Effect_1(s16 *data, u8 taskId) } } -void Unk44Effect_2(s16 *data, u8 taskId) +static void Unk44Effect_2(s16 *data, u8 taskId) { if (!gPaletteFade.active && !FuncIsActiveTask(sub_8087B14)) { @@ -3847,7 +3846,7 @@ void Unk44Effect_2(s16 *data, u8 taskId) } } -void sub_8087CFC(struct Sprite* sprite) +static void sub_8087CFC(struct Sprite* sprite) { int i; int xPos = (s16)gTotalCameraPixelOffsetX + sprite->pos1.x + sprite->pos2.x; @@ -3865,7 +3864,7 @@ void sub_8087CFC(struct Sprite* sprite) } } -void SpriteCB_FldEffUnk44(struct Sprite* sprite) +static void SpriteCB_FldEffUnk44(struct Sprite* sprite) { switch (sprite->data[0]) { @@ -3890,7 +3889,7 @@ void SpriteCB_FldEffUnk44(struct Sprite* sprite) DestroySprite(sprite); } -void Task_FldEffUnk45(u8 taskId) +static void Task_FldEffUnk45(u8 taskId) { if (!gPaletteFade.active) { -- cgit v1.2.3 From d12dd578b859e4413bea7341f63a887cbb59f94f Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 2 Mar 2020 11:16:34 -0500 Subject: Address review comments --- src/field_effect.c | 332 ++++++++++++++++++++++++++--------------------------- 1 file changed, 166 insertions(+), 166 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 5553f16dc..b0ff99659 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -56,17 +56,17 @@ static void SpriteCB_HallOfFameMonitor(struct Sprite * sprite); static const u16 sNewGameOakObjectSpriteTiles[] = INCBIN_U16("graphics/field_effects/unk_83CA770.4bpp"); static const u16 sNewGameOakObjectPals[] = INCBIN_U16("graphics/field_effects/unk_83CAF70.gbapal"); -static const u16 gUnknown_83CAF90[] = INCBIN_U16("graphics/field_effects/unk_83CAF90.4bpp"); -static const u16 gUnknown_83CAFB0[] = INCBIN_U16("graphics/field_effects/unk_83CAFB0.gbapal"); -static const u16 gUnknown_83CAFD0[] = INCBIN_U16("graphics/field_effects/unk_83CAFD0.4bpp"); -static const u16 gUnknown_83CB3D0[] = INCBIN_U16("graphics/field_effects/unk_83CB3D0.gbapal"); -static const u16 gUnknown_83CB3F0[] = INCBIN_U16("graphics/field_effects/unk_83CB3F0.4bpp"); -static const u16 gFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CB5F0.4bpp"); -static const u16 gFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CB7F0.gbapal"); -static const u16 gFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CB810.bin"); -static const u16 gDarknessFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp"); -static const u16 gDarknessFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal"); -static const u16 gDarknessFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin"); +static const u16 sUnknown_83CAF90[] = INCBIN_U16("graphics/field_effects/unk_83CAF90.4bpp"); +static const u16 sUnknown_83CAFB0[] = INCBIN_U16("graphics/field_effects/unk_83CAFB0.gbapal"); +static const u16 sUnknown_83CAFD0[] = INCBIN_U16("graphics/field_effects/unk_83CAFD0.4bpp"); +static const u16 sUnknown_83CB3D0[] = INCBIN_U16("graphics/field_effects/unk_83CB3D0.gbapal"); +static const u16 sUnknown_83CB3F0[] = INCBIN_U16("graphics/field_effects/unk_83CB3F0.4bpp"); +static const u16 sFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CB5F0.4bpp"); +static const u16 sFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CB7F0.gbapal"); +static const u16 sFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CB810.bin"); +static const u16 sDarknessFieldMoveStreaksTiles[] = INCBIN_U16("graphics/field_effects/unk_83CBA90.4bpp"); +static const u16 sDarknessFieldMoveStreaksPalette[] = INCBIN_U16("graphics/field_effects/unk_83CBB10.gbapal"); +static const u16 sDarknessFieldMoveStreaksTilemap[] = INCBIN_U16("graphics/field_effects/unk_83CBB30.bin"); static const u16 sFldEffUnk44_Tiles[] = INCBIN_U16("graphics/field_effects/unk_83CBDB0.4bpp"); static bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = { @@ -80,7 +80,7 @@ static bool8 (*const sFldEffScrcmdTable[])(const u8 **script, u32 *result) = { FieldEffectCmd_loadfadedpal_callnative }; -static const struct OamData gNewGameOakOamAttributes = { +static const struct OamData sNewGameOakOamAttributes = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, @@ -128,42 +128,42 @@ static const struct OamData sOamData_16x16 = { .affineParam = 0 }; -static const struct SpriteFrameImage gNewGameOakObjectSpriteFrames[] = { +static const struct SpriteFrameImage sNewGameOakObjectSpriteFrames[] = { {sNewGameOakObjectSpriteTiles, 0x800} }; -static const struct SpritePalette gNewGameOakObjectPaletteInfo = { +static const struct SpritePalette sNewGameOakObjectPaletteInfo = { sNewGameOakObjectPals, 4102 }; -static const union AnimCmd gNewGameOakAnim[] = { +static const union AnimCmd sNewGameOakAnim[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_END }; -static const union AnimCmd *const gNewGameOakAnimTable[] = { - gNewGameOakAnim +static const union AnimCmd *const sNewGameOakAnimTable[] = { + sNewGameOakAnim }; -static const struct SpriteTemplate gNewGameOakObjectTemplate = { - .tileTag = 0xFFFF, +static const struct SpriteTemplate sNewGameOakObjectTemplate = { + .tileTag = SPRITE_INVALID_TAG, .paletteTag = 4102, - .oam = &gNewGameOakOamAttributes, - .anims = gNewGameOakAnimTable, - .images = gNewGameOakObjectSpriteFrames, + .oam = &sNewGameOakOamAttributes, + .anims = sNewGameOakAnimTable, + .images = sNewGameOakObjectSpriteFrames, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCallbackDummy }; const struct SpritePalette gUnknown_83CBE9C = { - gUnknown_83CAFB0, 4103 + sUnknown_83CAFB0, 4103 }; const struct SpritePalette gUnknown_83CBEA4 = { - gUnknown_83CB3D0, 4112 + sUnknown_83CB3D0, 4112 }; -static const struct OamData gOamData_83CBEAC = { +static const struct OamData sOamData_83CBEAC = { .y = 0, .affineMode = ST_OAM_AFFINE_OFF, .objMode = ST_OAM_OBJ_NORMAL, @@ -179,25 +179,25 @@ static const struct OamData gOamData_83CBEAC = { .affineParam = 0 }; -static const struct SpriteFrameImage gUnknown_83CBEB4[] = { - {gUnknown_83CAF90, 0x20} +static const struct SpriteFrameImage sUnknown_83CBEB4[] = { + {sUnknown_83CAF90, 0x20} }; -static const struct SpriteFrameImage gUnknown_83CBEBC[] = { - {gUnknown_83CAFD0 + 0x000, 0x100}, - {gUnknown_83CAFD0 + 0x080, 0x100}, - {gUnknown_83CAFD0 + 0x100, 0x100}, - {gUnknown_83CAFD0 + 0x180, 0x100} +static const struct SpriteFrameImage sUnknown_83CBEBC[] = { + {sUnknown_83CAFD0 + 0x000, 0x100}, + {sUnknown_83CAFD0 + 0x080, 0x100}, + {sUnknown_83CAFD0 + 0x100, 0x100}, + {sUnknown_83CAFD0 + 0x180, 0x100} }; -static const struct SpriteFrameImage gUnknown_83CBEDC[] = { - {gUnknown_83CB3F0 + 0x00, 0x80}, - {gUnknown_83CB3F0 + 0x40, 0x80}, - {gUnknown_83CB3F0 + 0x80, 0x80}, - {gUnknown_83CB3F0 + 0xC0, 0x80} +static const struct SpriteFrameImage sUnknown_83CBEDC[] = { + {sUnknown_83CB3F0 + 0x00, 0x80}, + {sUnknown_83CB3F0 + 0x40, 0x80}, + {sUnknown_83CB3F0 + 0x80, 0x80}, + {sUnknown_83CB3F0 + 0xC0, 0x80} }; -static const struct Subsprite gUnknown_83CBEFC[] = +static const struct Subsprite sUnknown_83CBEFC[] = { { .x = -12, @@ -230,9 +230,9 @@ static const struct Subsprite gUnknown_83CBEFC[] = } }; -static const struct SubspriteTable gUnknown_83CBF0C = subsprite_table(gUnknown_83CBEFC); +static const struct SubspriteTable sUnknown_83CBF0C = subsprite_table(sUnknown_83CBEFC); -static const struct Subsprite gUnknown_83CBF14[] = +static const struct Subsprite sUnknown_83CBF14[] = { { .x = -32, @@ -265,14 +265,14 @@ static const struct Subsprite gUnknown_83CBF14[] = } }; -static const struct SubspriteTable gUnknown_83CBF24 = subsprite_table(gUnknown_83CBF14); +static const struct SubspriteTable sUnknown_83CBF24 = subsprite_table(sUnknown_83CBF14); -static const union AnimCmd gUnknown_83CBF2C[] = { +static const union AnimCmd sUnknown_83CBF2C[] = { ANIMCMD_FRAME(0, 1), ANIMCMD_JUMP(0) }; -static const union AnimCmd gUnknown_83CBF34[] = { +static const union AnimCmd sUnknown_83CBF34[] = { ANIMCMD_FRAME(1, 5), ANIMCMD_FRAME(2, 5), ANIMCMD_FRAME(3, 7), @@ -283,12 +283,12 @@ static const union AnimCmd gUnknown_83CBF34[] = { ANIMCMD_END }; -static const union AnimCmd *const gUnknown_83CBF54[] = { - gUnknown_83CBF2C, - gUnknown_83CBF34 +static const union AnimCmd *const sUnknown_83CBF54[] = { + sUnknown_83CBF2C, + sUnknown_83CBF34 }; -static const union AnimCmd gUnknown_83CBF5C[] = { +static const union AnimCmd sUnknown_83CBF5C[] = { ANIMCMD_FRAME(3, 8), ANIMCMD_FRAME(2, 8), ANIMCMD_FRAME(1, 8), @@ -301,36 +301,36 @@ static const union AnimCmd gUnknown_83CBF5C[] = { ANIMCMD_END }; -static const union AnimCmd *const gUnknown_83CBF84[] = { - gUnknown_83CBF5C +static const union AnimCmd *const sUnknown_83CBF84[] = { + sUnknown_83CBF5C }; -static const struct SpriteTemplate gUnknown_83CBF88 = { - .tileTag = 65535, +static const struct SpriteTemplate sUnknown_83CBF88 = { + .tileTag = SPRITE_INVALID_TAG, .paletteTag = 4103, .oam = &sOamData_8x8, - .anims = gUnknown_83CBF54, - .images = gUnknown_83CBEB4, + .anims = sUnknown_83CBF54, + .images = sUnknown_83CBEB4, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_PokeballGlow }; -static const struct SpriteTemplate gUnknown_83CBFA0 = { - .tileTag = 65535, +static const struct SpriteTemplate sUnknown_83CBFA0 = { + .tileTag = SPRITE_INVALID_TAG, .paletteTag = 4103, - .oam = &gOamData_83CBEAC, - .anims = gUnknown_83CBF54, - .images = gUnknown_83CBEBC, + .oam = &sOamData_83CBEAC, + .anims = sUnknown_83CBF54, + .images = sUnknown_83CBEBC, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_PokecenterMonitor }; -static const struct SpriteTemplate gUnknown_83CBFB8 = { - .tileTag = 65535, +static const struct SpriteTemplate sUnknown_83CBFB8 = { + .tileTag = SPRITE_INVALID_TAG, .paletteTag = 4112, .oam = &sOamData_16x16, - .anims = gUnknown_83CBF84, - .images = gUnknown_83CBEDC, + .anims = sUnknown_83CBF84, + .images = sUnknown_83CBEDC, .affineAnims = gDummySpriteAffineAnimTable, .callback = SpriteCB_HallOfFameMonitor }; @@ -565,7 +565,7 @@ u8 CreateTrainerSprite(u8 trainerSpriteID, s16 x, s16 y, u8 subpriority, u8 *buf LoadCompressedSpriteSheetOverrideBuffer(&gTrainerFrontPicTable[trainerSpriteID], buffer); spriteTemplate.tileTag = gTrainerFrontPicTable[trainerSpriteID].tag; spriteTemplate.paletteTag = gTrainerFrontPicPaletteTable[trainerSpriteID].tag; - spriteTemplate.oam = &gNewGameOakOamAttributes; + spriteTemplate.oam = &sNewGameOakOamAttributes; spriteTemplate.anims = gDummySpriteAnimTable; spriteTemplate.images = NULL; spriteTemplate.affineAnims = gDummySpriteAffineAnimTable; @@ -581,8 +581,8 @@ static void LoadTrainerGfx_TrainerCard(u8 gender, u16 palOffset, u8 *dest) static u8 AddNewGameBirchObject(s16 x, s16 y, u8 subpriority) { - LoadSpritePalette(&gNewGameOakObjectPaletteInfo); - return CreateSprite(&gNewGameOakObjectTemplate, x, y, subpriority); + LoadSpritePalette(&sNewGameOakObjectPaletteInfo); + return CreateSprite(&sNewGameOakObjectTemplate, x, y, subpriority); } u8 CreateMonSprite_PicBox(u16 species, s16 x, s16 y, u8 subpriority) @@ -835,7 +835,7 @@ static void SpriteCB_PokeballGlowEffect(struct Sprite * sprite) sPokeballGlowSpriteCBTable[sprite->data[0]](sprite); } -static const struct Coords16 gUnknown_83CC010[] = { +static const struct Coords16 sUnknown_83CC010[] = { {0, 0}, {6, 0}, {0, 4}, @@ -844,9 +844,9 @@ static const struct Coords16 gUnknown_83CC010[] = { {6, 8} }; -static const u8 gUnknown_83CC028[] = {16, 12, 8, 0}; -static const u8 gUnknown_83CC02C[] = {16, 12, 8, 0}; -static const u8 gUnknown_83CC030[] = { 0, 0, 0, 0}; +static const u8 sUnknown_83CC028[] = {16, 12, 8, 0}; +static const u8 sUnknown_83CC02C[] = {16, 12, 8, 0}; +static const u8 sUnknown_83CC030[] = { 0, 0, 0, 0}; static void PokeballGlowEffect_0(struct Sprite * sprite) { @@ -854,7 +854,7 @@ static void PokeballGlowEffect_0(struct Sprite * sprite) if (sprite->data[1] == 0 || (--sprite->data[1]) == 0) { sprite->data[1] = 25; - endSpriteId = CreateSpriteAtEnd(&gUnknown_83CBF88, gUnknown_83CC010[sprite->data[2]].x + sprite->pos2.x, gUnknown_83CC010[sprite->data[2]].y + sprite->pos2.y, 0xFF); + endSpriteId = CreateSpriteAtEnd(&sUnknown_83CBF88, sUnknown_83CC010[sprite->data[2]].x + sprite->pos2.x, sUnknown_83CC010[sprite->data[2]].y + sprite->pos2.y, 0xFF); gSprites[endSpriteId].oam.priority = 2; gSprites[endSpriteId].data[0] = sprite->data[7]; sprite->data[2]++; @@ -897,14 +897,14 @@ static void PokeballGlowEffect_2(struct Sprite * sprite) } } phase = (sprite->data[2] + 3) & 3; - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x108, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x108, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); phase = (sprite->data[2] + 2) & 3; - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x106, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x106, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); phase = (sprite->data[2] + 1) & 3; - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x102, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x102, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); phase = sprite->data[2]; - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x105, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x105, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); if (sprite->data[3] > 2) { sprite->data[0]++; @@ -928,11 +928,11 @@ static void PokeballGlowEffect_3(struct Sprite * sprite) } } phase = sprite->data[2]; - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x108, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x106, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x102, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x105, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); - MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, gUnknown_83CC028[phase], gUnknown_83CC02C[phase], gUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x108, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x106, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x102, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x105, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); + MultiplyInvertedPaletteRGBComponents((IndexOfSpritePaletteTag(0x1007) << 4) + 0x103, sUnknown_83CC028[phase], sUnknown_83CC02C[phase], sUnknown_83CC030[phase]); } static void PokeballGlowEffect_4(struct Sprite * sprite) @@ -970,7 +970,7 @@ static u8 PokecenterHealEffectHelper(s32 x, s32 y) { u8 spriteId; struct Sprite * sprite; - spriteId = CreateSpriteAtEnd(&gUnknown_83CBFA0, x, y, 0); + spriteId = CreateSpriteAtEnd(&sUnknown_83CBFA0, x, y, 0); sprite = &gSprites[spriteId]; sprite->oam.priority = 2; sprite->invisible = TRUE; @@ -991,7 +991,7 @@ static void SpriteCB_PokecenterMonitor(struct Sprite * sprite) static void HallOfFameRecordEffectHelper(s32 x, s32 y) { - CreateSpriteAtEnd(&gUnknown_83CBFB8, x, y, 0); + CreateSpriteAtEnd(&sUnknown_83CBFB8, x, y, 0); } static void SpriteCB_HallOfFameMonitor(struct Sprite * sprite) @@ -1128,7 +1128,7 @@ static bool8 FallWarpEffect_1(struct Task * task) gPlayerAvatar.preventStep = TRUE; ObjectEventSetHeldMovement(playerObject, GetFaceDirectionMovementAction(GetPlayerFacingDirection())); task->data[4] = playerSprite->subspriteMode; - playerObject->fixedPriority = 1; + playerObject->fixedPriority = TRUE; playerSprite->oam.priority = 1; playerSprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY; task->data[0]++; @@ -1178,15 +1178,15 @@ static bool8 FallWarpEffect_4(struct Task * task) if (task->data[3] == 0 && sprite->pos2.y >= -16) { task->data[3]++; - objectEvent->fixedPriority = 0; + objectEvent->fixedPriority = FALSE; sprite->subspriteMode = task->data[4]; - objectEvent->triggerGroundEffectsOnMove = 1; + objectEvent->triggerGroundEffectsOnMove = TRUE; } if (sprite->pos2.y >= 0) { PlaySE(SE_W070); - objectEvent->triggerGroundEffectsOnStop = 1; - objectEvent->landingJump = 1; + objectEvent->triggerGroundEffectsOnStop = TRUE; + objectEvent->landingJump = TRUE; sprite->pos2.y = 0; task->data[0]++; } @@ -1710,7 +1710,7 @@ static bool8 LavaridgeGymB1FWarpEffect_1(struct Task * task, struct ObjectEvent CameraObjectReset2(); SetCameraPanningCallback(NULL); gPlayerAvatar.preventStep = TRUE; - objectEvent->fixedPriority = 1; + objectEvent->fixedPriority = TRUE; task->data[1] = 1; task->data[0]++; return TRUE; @@ -1775,7 +1775,7 @@ static bool8 LavaridgeGymB1FWarpEffect_4(struct Task * task, struct ObjectEvent if (task->data[5] == 0 && sprite->pos2.y < -0x10) { task->data[5]++; - objectEvent->fixedPriority = 1; + objectEvent->fixedPriority = TRUE; sprite->oam.priority = 1; sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY; } @@ -1927,7 +1927,7 @@ static bool8 LavaridgeGym1FWarpEffect_1(struct Task * task, struct ObjectEvent * FreezeObjectEvents(); CameraObjectReset2(); gPlayerAvatar.preventStep = TRUE; - objectEvent->fixedPriority = 1; + objectEvent->fixedPriority = TRUE; task->data[0]++; return FALSE; } @@ -2070,7 +2070,7 @@ static void EscapeRopeFieldEffect_Step1(struct Task * task) } } -static const u8 gUnknown_83CC0E8[] = { +static const u8 sUnknown_83CC0E8[] = { [DIR_NONE] = DIR_SOUTH, [DIR_SOUTH] = DIR_WEST, [DIR_WEST] = DIR_NORTH, @@ -2084,11 +2084,11 @@ static u8 sub_808576C(struct ObjectEvent * playerObj, s16 *delay_p, s16 *stage_p { if (*delay_p != 0 && --(*delay_p) != 0) return playerObj->facingDirection; - ObjectEventSetHeldMovement(playerObj, GetFaceDirectionMovementAction(gUnknown_83CC0E8[playerObj->facingDirection])); + ObjectEventSetHeldMovement(playerObj, GetFaceDirectionMovementAction(sUnknown_83CC0E8[playerObj->facingDirection])); if (*stage_p < 12) (*stage_p)++; *delay_p = 12 >> (*stage_p); // 12 >> 4 = 0 - return gUnknown_83CC0E8[playerObj->facingDirection]; + return sUnknown_83CC0E8[playerObj->facingDirection]; } return playerObj->facingDirection; } @@ -2391,7 +2391,7 @@ static void TeleportInFieldEffectTask2(struct Task * task) if (task->data[13] == 0) { task->data[13]++; - objectEvent->triggerGroundEffectsOnMove = 1; + objectEvent->triggerGroundEffectsOnMove = TRUE; sprite->subspriteMode = task->data[14]; } } else @@ -2509,10 +2509,10 @@ static void ShowMonEffect_Outdoors_1(struct Task * task) task->data[11] = GetGpuReg(REG_OFFSET_WININ); task->data[12] = GetGpuReg(REG_OFFSET_WINOUT); StoreWordInTwoHalfwords((u16*)&task->data[13], (u32)gMain.vblankCallback); - task->data[1] = 0xf0f1; - task->data[2] = 0x5051; - task->data[3] = 0x3f; - task->data[4] = 0x3e; + task->data[1] = WIN_RANGE(0xF0, 0xF1); + task->data[2] = WIN_RANGE(0x50, 0x51); + task->data[3] = WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN0_CLR; + task->data[4] = WINOUT_WIN01_BG1 | WINOUT_WIN01_BG2 | WINOUT_WIN01_BG3 | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR; SetGpuReg(REG_OFFSET_WIN0H, task->data[1]); SetGpuReg(REG_OFFSET_WIN0V, task->data[2]); SetGpuReg(REG_OFFSET_WININ, task->data[3]); @@ -2525,40 +2525,40 @@ static void ShowMonEffect_Outdoors_2(struct Task * task) { u16 charbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 2) << 14); u16 screenbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11); - CpuCopy16(gFieldMoveStreaksTiles, (void *)(VRAM + charbase), 0x200); + CpuCopy16(sFieldMoveStreaksTiles, (void *)(VRAM + charbase), 0x200); CpuFill32(0, (void *)(VRAM + screenbase), 0x800); - LoadPalette(gFieldMoveStreaksPalette, 0xf0, 0x20); + LoadPalette(sFieldMoveStreaksPalette, 0xf0, 0x20); LoadFieldMoveStreaksTilemapToVram(screenbase); task->data[0]++; } static void ShowMonEffect_Outdoors_3(struct Task * task) { - s16 v0; - s16 v2; - s16 v3; + s16 win0h_lo; + s16 win0v_lo; + s16 win0v_hi; task->data[5] -= 16; - v0 = ((u16)task->data[1] >> 8); - v2 = ((u16)task->data[2] >> 8); - v3 = ((u16)task->data[2] & 0xff); - v0 -= 16; - v2 -= 2; - v3 += 2; - if (v0 < 0) + win0h_lo = ((u16)task->data[1] >> 8); + win0v_lo = ((u16)task->data[2] >> 8); + win0v_hi = ((u16)task->data[2] & 0xff); + win0h_lo -= 16; + win0v_lo -= 2; + win0v_hi += 2; + if (win0h_lo < 0) { - v0 = 0; + win0h_lo = 0; } - if (v2 < 0x28) + if (win0v_lo < 0x28) { - v2 = 0x28; + win0v_lo = 0x28; } - if (v3 > 0x78) + if (win0v_hi > 0x78) { - v3 = 0x78; + win0v_hi = 0x78; } - task->data[1] = (v0 << 8) | (task->data[1] & 0xff); - task->data[2] = (v2 << 8) | v3; - if (v0 == 0 && v2 == 0x28 && v3 == 0x78) + task->data[1] = WIN_RANGE(win0h_lo, task->data[1] & 0xff); + task->data[2] = WIN_RANGE(win0v_lo, win0v_hi); + if (win0h_lo == 0 && win0v_lo == 0x28 && win0v_hi == 0x78) { gSprites[task->data[15]].callback = sub_80868C0; task->data[0]++; @@ -2576,23 +2576,23 @@ static void ShowMonEffect_Outdoors_4(struct Task * task) static void ShowMonEffect_Outdoors_5(struct Task * task) { - s16 v2; - s16 v3; + s16 win0v_lo; + s16 win0v_hi; task->data[5] -= 16; - v2 = (task->data[2] >> 8); - v3 = (task->data[2] & 0xff); - v2 += 6; - v3 -= 6; - if (v2 > 0x50) + win0v_lo = (task->data[2] >> 8); + win0v_hi = (task->data[2] & 0xff); + win0v_lo += 6; + win0v_hi -= 6; + if (win0v_lo > 0x50) { - v2 = 0x50; + win0v_lo = 0x50; } - if (v3 < 0x51) + if (win0v_hi < 0x51) { - v3 = 0x51; + win0v_hi = 0x51; } - task->data[2] = (v2 << 8) | v3; - if (v2 == 0x50 && v3 == 0x51) + task->data[2] = WIN_RANGE(win0v_lo, win0v_hi); + if (win0v_lo == 0x50 && win0v_hi == 0x51) { task->data[0]++; } @@ -2602,8 +2602,8 @@ static void ShowMonEffect_Outdoors_6(struct Task * task) { u16 bg0cnt = (GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11; CpuFill32(0, (void *)VRAM + bg0cnt, 0x800); - task->data[1] = 0xf1; - task->data[2] = 0xa1; + task->data[1] = WIN_RANGE(0x00, 0xf1); + task->data[2] = WIN_RANGE(0x00, 0xa1); task->data[3] = task->data[11]; task->data[4] = task->data[12]; task->data[0]++; @@ -2612,7 +2612,7 @@ static void ShowMonEffect_Outdoors_6(struct Task * task) static void ShowMonEffect_Outdoors_7(struct Task * task) { IntrCallback callback; - LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&callback); + LoadWordFromTwoHalfwords((u16 *)&task->data[13], (uintptr_t *)&callback); SetVBlankCallback(callback); ChangeBgX(0, 0, 0); ChangeBgY(0, 0, 0); @@ -2626,7 +2626,7 @@ static void VBlankCB_ShowMonEffect_Outdoors(void) { IntrCallback callback; struct Task * task = &gTasks[FindTaskIdByFunc(Task_ShowMon_Outdoors)]; - LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&callback); + LoadWordFromTwoHalfwords((u16 *)&task->data[13], (uintptr_t *)&callback); callback(); SetGpuReg(REG_OFFSET_WIN0H, task->data[1]); SetGpuReg(REG_OFFSET_WIN0V, task->data[2]); @@ -2643,7 +2643,7 @@ static void LoadFieldMoveStreaksTilemapToVram(u16 screenbase) dest = (u16 *)(VRAM + (10 * 32) + screenbase); for (i = 0; i < (10 * 32); i++, dest++) { - *dest = gFieldMoveStreaksTilemap[i] | METATILE_ELEVATION_MASK; + *dest = sFieldMoveStreaksTilemap[i] | METATILE_ELEVATION_MASK; } } @@ -2678,9 +2678,9 @@ static void ShowMonEffect_Indoors_2(struct Task * task) charbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 2) << 14); screenbase = ((GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11); task->data[12] = screenbase; - CpuCopy16(gDarknessFieldMoveStreaksTiles, (void *)(VRAM + charbase), 0x80); + CpuCopy16(sDarknessFieldMoveStreaksTiles, (void *)(VRAM + charbase), 0x80); CpuFill32(0, (void *)(VRAM + screenbase), 0x800); - LoadPalette(gDarknessFieldMoveStreaksPalette, 0xf0, 0x20); + LoadPalette(sDarknessFieldMoveStreaksPalette, 0xf0, 0x20); task->data[0]++; } @@ -2689,9 +2689,9 @@ static void ShowMonEffect_Indoors_3(struct Task * task) if (sub_8086738(task)) { task->data[5] = GetGpuReg(REG_OFFSET_WININ); - SetGpuReg(REG_OFFSET_WININ, (task->data[5] & 0xFF) | 0x1100); - SetGpuReg(REG_OFFSET_WIN1H, 0x00f0); - SetGpuReg(REG_OFFSET_WIN1V, 0x2878); + SetGpuReg(REG_OFFSET_WININ, (task->data[5] & 0xFF) | WININ_WIN1_BG0 | WININ_WIN1_OBJ); + SetGpuReg(REG_OFFSET_WIN1H, WIN_RANGE(0x00, 0xf0)); + SetGpuReg(REG_OFFSET_WIN1V, WIN_RANGE(0x28, 0x78)); gSprites[task->data[15]].callback = sub_80868C0; task->data[0]++; } @@ -2712,8 +2712,8 @@ static void ShowMonEffect_Indoors_5(struct Task * task) sub_8086728(task); task->data[3] = task->data[1] & 7; task->data[4] = 0; - SetGpuReg(REG_OFFSET_WIN1H, 0xffff); - SetGpuReg(REG_OFFSET_WIN1V, 0xffff); + SetGpuReg(REG_OFFSET_WIN1H, WIN_RANGE(0xff, 0xff)); + SetGpuReg(REG_OFFSET_WIN1V, WIN_RANGE(0xff, 0xff)); SetGpuReg(REG_OFFSET_WININ, task->data[5]); task->data[0]++; } @@ -2733,7 +2733,7 @@ static void ShowMonEffect_Indoors_7(struct Task * task) u16 charbase; charbase = (GetGpuReg(REG_OFFSET_BG0CNT) >> 8) << 11; CpuFill32(0, (void *)VRAM + charbase, 0x800); - LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&intrCallback); + LoadWordFromTwoHalfwords((u16 *)&task->data[13], (uintptr_t *)&intrCallback); SetVBlankCallback(intrCallback); ChangeBgX(0, 0, 0); ChangeBgY(0, 0, 0); @@ -2748,7 +2748,7 @@ static void VBlankCB_ShowMonEffect_Indoors(void) IntrCallback intrCallback; struct Task * task; task = &gTasks[FindTaskIdByFunc(Task_ShowMon_Indoors)]; - LoadWordFromTwoHalfwords((u16 *)&task->data[13], (u32 *)&intrCallback); + LoadWordFromTwoHalfwords((u16 *)&task->data[13], (uintptr_t *)&intrCallback); intrCallback(); SetGpuReg(REG_OFFSET_BG0HOFS, task->data[1]); SetGpuReg(REG_OFFSET_BG0VOFS, task->data[2]); @@ -2778,10 +2778,10 @@ static bool8 sub_8086738(struct Task * task) dest = (u16 *)(VRAM + 0x140 + (u16)task->data[12]); for (i = 0; i < 10; i++) { - dest[dstOffs + i * 32] = gDarknessFieldMoveStreaksTilemap[srcOffs + i * 32]; + dest[dstOffs + i * 32] = sDarknessFieldMoveStreaksTilemap[srcOffs + i * 32]; dest[dstOffs + i * 32] |= 0xf000; - dest[((dstOffs + 1) & 0x1f) + i * 32] = gDarknessFieldMoveStreaksTilemap[((srcOffs + 1) & 0x1f) + i * 32] | 0xf000; + dest[((dstOffs + 1) & 0x1f) + i * 32] = sDarknessFieldMoveStreaksTilemap[((srcOffs + 1) & 0x1f) + i * 32] | 0xf000; dest[((dstOffs + 1) & 0x1f) + i * 32] |= 0xf000; } task->data[4] += 2; @@ -3188,7 +3188,7 @@ static void UseFlyEffect_6(struct Task * task) struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2)); StartSpriteAnim(&gSprites[objectEvent->spriteId], 0x16); - objectEvent->inanimate = 1; + objectEvent->inanimate = TRUE; ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_JUMP_IN_PLACE_LEFT); task->data[0]++; task->data[2] = 0; @@ -3201,8 +3201,8 @@ static void UseFlyEffect_7(struct Task * task) { struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; ObjectEventClearAnimIfSpecialAnimActive(objectEvent); - objectEvent->inanimate = 0; - objectEvent->hasShadow = 0; + objectEvent->inanimate = FALSE; + objectEvent->hasShadow = FALSE; sub_8087204(task->data[1], objectEvent->spriteId); StartSpriteAnim(&gSprites[task->data[1]], gSaveBlock2Ptr->playerGender * 2 + 1); sub_80877FC(&gSprites[task->data[1]], 0); @@ -3265,21 +3265,21 @@ static void sub_8087204(u8 a0, u8 a1) gSprites[a0].data[6] = a1; } -static const union AffineAnimCmd gUnknown_83CC19C[] = { +static const union AffineAnimCmd sUnknown_83CC19C[] = { AFFINEANIMCMD_FRAME( 8, 8, 226, 0), AFFINEANIMCMD_FRAME(28, 28, 0, 30), AFFINEANIMCMD_END }; -static const union AffineAnimCmd gUnknown_83CC1B4[] = { +static const union AffineAnimCmd sUnknown_83CC1B4[] = { AFFINEANIMCMD_FRAME(256, 256, 64, 0), AFFINEANIMCMD_FRAME(-10, -10, 0, 22), AFFINEANIMCMD_END }; -static const union AffineAnimCmd *const gUnknown_83CC1CC[] = { - gUnknown_83CC19C, - gUnknown_83CC1B4 +static const union AffineAnimCmd *const sUnknown_83CC1CC[] = { + sUnknown_83CC19C, + sUnknown_83CC1B4 }; static void sub_8087220(struct Sprite * sprite) @@ -3289,7 +3289,7 @@ static void sub_8087220(struct Sprite * sprite) if (sprite->data[0] == 0) { sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; - sprite->affineAnims = gUnknown_83CC1CC; + sprite->affineAnims = sUnknown_83CC1CC; InitSpriteAffineAnim(sprite); StartSpriteAffineAnim(sprite, 0); if (gSaveBlock2Ptr->playerGender == MALE) @@ -3345,7 +3345,7 @@ static void sub_8087364(struct Sprite * sprite) if (sprite->data[0] == 0) { sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; - sprite->affineAnims = gUnknown_83CC1CC; + sprite->affineAnims = sUnknown_83CC1CC; InitSpriteAffineAnim(sprite); StartSpriteAffineAnim(sprite, 1); if (gSaveBlock2Ptr->playerGender == MALE) @@ -3508,7 +3508,7 @@ static void FlyInEffect_4(struct Task * task) { objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; sprite = &gSprites[objectEvent->spriteId]; - objectEvent->inanimate = 0; + objectEvent->inanimate = FALSE; sub_805F724(objectEvent, objectEvent->currentCoords.x, objectEvent->currentCoords.y); sprite->pos2.x = 0; sprite->pos2.y = 0; @@ -3560,26 +3560,26 @@ static void FlyInEffect_7(struct Task * task) } } -static const union AffineAnimCmd gUnknown_83CC214[] = { +static const union AffineAnimCmd sUnknown_83CC214[] = { AFFINEANIMCMD_FRAME(24, 24, 0, 1), AFFINEANIMCMD_JUMP(0) }; -static const union AffineAnimCmd gUnknown_83CC224[] = { +static const union AffineAnimCmd sUnknown_83CC224[] = { AFFINEANIMCMD_FRAME(512, 512, 0, 1), AFFINEANIMCMD_FRAME(-16, -16, 0, 1), AFFINEANIMCMD_JUMP(1) }; -static const union AffineAnimCmd *const gUnknown_83CC23C[] = { - gUnknown_83CC214, - gUnknown_83CC224 +static const union AffineAnimCmd *const sUnknown_83CC23C[] = { + sUnknown_83CC214, + sUnknown_83CC224 }; static void sub_80877FC(struct Sprite * sprite, u8 affineAnimId) { sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; - sprite->affineAnims = gUnknown_83CC23C; + sprite->affineAnims = sUnknown_83CC23C; InitSpriteAffineAnim(sprite); StartSpriteAffineAnim(sprite, affineAnimId); } @@ -3735,8 +3735,8 @@ static const union AnimCmd *const sAnimCmdTable_FldEffUnk44[] = { sAnimCmd_FldEffUnk44_3 }; -static const struct SpriteTemplate gUnknown_83CC2A0 = { - .tileTag = 0xFFFF, +static const struct SpriteTemplate sUnknown_83CC2A0 = { + .tileTag = SPRITE_INVALID_TAG, .paletteTag = 4371, .oam = &sOamData_8x8, .anims = sAnimCmdTable_FldEffUnk44, @@ -3854,7 +3854,7 @@ static void sub_8087CFC(struct Sprite* sprite) for (i = 0; i < 4; i++) { - u8 spriteId = CreateSprite(&gUnknown_83CC2A0, xPos, yPos, 0); + u8 spriteId = CreateSprite(&sUnknown_83CC2A0, xPos, yPos, 0); if (spriteId != MAX_SPRITES) { StartSpriteAnim(&gSprites[spriteId], i); -- cgit v1.2.3 From b3803dcc99703ef863802616697e4f39cfb7398d Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 2 Mar 2020 11:53:08 -0500 Subject: Address review comments, 2 --- src/field_effect.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index b0ff99659..fbd98315a 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -412,7 +412,7 @@ static u32 FieldEffectScript_ReadWord(const u8 **script) static void FieldEffectScript_LoadTiles(const u8 **script) { const struct SpriteSheet * spriteSheet = (const struct SpriteSheet * )FieldEffectScript_ReadWord(script); - if (GetSpriteTileStartByTag(spriteSheet->tag) == 0xFFFF) + if (GetSpriteTileStartByTag(spriteSheet->tag) == SPRITE_INVALID_TAG) LoadSpriteSheet(spriteSheet); *script += sizeof(u32); } @@ -486,7 +486,7 @@ static void FieldEffectFreeTilesIfUnused(u16 tileStart) { u8 i; u16 tileTag = GetSpriteTileTagByTileStart(tileStart); - if (tileTag == 0xFFFF) + if (tileTag == SPRITE_INVALID_TAG) return; for (i = 0; i < MAX_SPRITES; i++) { @@ -500,7 +500,7 @@ static void FieldEffectFreePaletteIfUnused(u8 paletteNum) { u8 i; u16 paletteTag = GetSpritePaletteTagByPaletteNum(paletteNum); - if (paletteTag == 0xFFFF) + if (paletteTag == SPRITE_INVALID_TAG) return; for (i = 0; i < MAX_SPRITES; i++) { @@ -1900,7 +1900,7 @@ u8 FldEff_LavaridgeGymWarp(void) sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[33], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); gSprites[spriteId].oam.priority = gFieldEffectArguments[3]; - gSprites[spriteId].coordOffsetEnabled = 1; + gSprites[spriteId].coordOffsetEnabled = TRUE; return spriteId; } @@ -1993,7 +1993,7 @@ u8 FldEff_PopOutOfAsh(void) sub_8063BC4((s16 *)&gFieldEffectArguments[0], (s16 *)&gFieldEffectArguments[1], 8, 8); spriteId = CreateSpriteAtEnd(gFieldEffectObjectTemplatePointers[32], gFieldEffectArguments[0], gFieldEffectArguments[1], gFieldEffectArguments[2]); gSprites[spriteId].oam.priority = gFieldEffectArguments[3]; - gSprites[spriteId].coordOffsetEnabled = 1; + gSprites[spriteId].coordOffsetEnabled = TRUE; return spriteId; } @@ -3064,7 +3064,7 @@ static void sub_8086D94(struct Sprite * sprite) if (sprite->data[0]) { npcSprite = &gSprites[sprite->data[1]]; - npcSprite->coordOffsetEnabled = 0; + npcSprite->coordOffsetEnabled = FALSE; npcSprite->pos1.x = sprite->pos1.x + sprite->pos2.x; npcSprite->pos1.y = sprite->pos1.y + sprite->pos2.y - 8; npcSprite->pos2.x = 0; @@ -3326,7 +3326,7 @@ static void sub_80872F0(struct Sprite * sprite) if (sprite->data[6] != MAX_SPRITES) { struct Sprite * sprite1 = &gSprites[sprite->data[6]]; - sprite1->coordOffsetEnabled = 0; + sprite1->coordOffsetEnabled = FALSE; sprite1->pos1.x = sprite->pos1.x + sprite->pos2.x; sprite1->pos1.y = sprite->pos1.y + sprite->pos2.y - 8; sprite1->pos2.x = 0; @@ -3512,7 +3512,7 @@ static void FlyInEffect_4(struct Task * task) sub_805F724(objectEvent, objectEvent->currentCoords.x, objectEvent->currentCoords.y); sprite->pos2.x = 0; sprite->pos2.y = 0; - sprite->coordOffsetEnabled = 1; + sprite->coordOffsetEnabled = TRUE; sub_805CB70(); ObjectEventSetHeldMovement(objectEvent, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION); task->data[0]++; -- cgit v1.2.3 From 2d820809d74eaf4775ad0e2cc50e57bb65ed61a6 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 2 Mar 2020 12:01:57 -0500 Subject: Revert erroneous use of SPRITE_INVALID_TAG --- src/field_effect.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index fbd98315a..9b2974f1f 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -412,7 +412,7 @@ static u32 FieldEffectScript_ReadWord(const u8 **script) static void FieldEffectScript_LoadTiles(const u8 **script) { const struct SpriteSheet * spriteSheet = (const struct SpriteSheet * )FieldEffectScript_ReadWord(script); - if (GetSpriteTileStartByTag(spriteSheet->tag) == SPRITE_INVALID_TAG) + if (GetSpriteTileStartByTag(spriteSheet->tag) == 0xFFFF) LoadSpriteSheet(spriteSheet); *script += sizeof(u32); } -- cgit v1.2.3 From 6363d39e99612904a0393a272bbb1748ef9dca20 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Mon, 2 Mar 2020 13:34:34 -0500 Subject: port field_effect_helpers from emerald --- src/field_effect.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 9b2974f1f..c7dd8b4e4 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -446,7 +446,7 @@ static void FieldEffectScript_LoadFadedPal(const u8 **script) LoadSpritePalette(spritePalette); if (idx == 0xFF) sub_8083598(IndexOfSpritePaletteTag(spritePalette->tag)); - sub_807AA8C(IndexOfSpritePaletteTag(spritePalette->tag)); + UpdateSpritePaletteWithWeather(IndexOfSpritePaletteTag(spritePalette->tag)); *script += sizeof(u32); } @@ -1604,7 +1604,7 @@ static bool8 waterfall_4_wait_player_move_probably(struct Task * task, struct Ob { if (!ObjectEventClearHeldMovementIfFinished(playerObj)) return FALSE; - if (MetatileBehavior_IsWaterfall(playerObj->mapobj_unk_1E)) + if (MetatileBehavior_IsWaterfall(playerObj->currentMetatileBehavior)) { task->data[0] = 3; return TRUE; @@ -1664,7 +1664,7 @@ static bool8 dive_3_unknown(struct Task * task) PlayerGetDestCoords(&pos.x, &pos.y); if (!FieldEffectActiveListContains(FLDEFF_FIELD_MOVE_SHOW_MON)) { - dive_warp(&pos, gObjectEvents[gPlayerAvatar.objectEventId].mapobj_unk_1E); + dive_warp(&pos, gObjectEvents[gPlayerAvatar.objectEventId].currentMetatileBehavior); DestroyTask(FindTaskIdByFunc(Task_Dive)); FieldEffectActiveListRemove(FLDEFF_USE_DIVE); } @@ -2904,7 +2904,7 @@ static void UseSurfEffect_1(struct Task * task) gPlayerAvatar.preventStep = TRUE; SetPlayerAvatarStateMask(8); PlayerGetDestCoords(&task->data[1], &task->data[2]); - MoveCoords(gObjectEvents[gPlayerAvatar.objectEventId].placeholder18, &task->data[1], &task->data[2]); + MoveCoords(gObjectEvents[gPlayerAvatar.objectEventId].movementDirection, &task->data[1], &task->data[2]); task->data[0]++; } @@ -2940,11 +2940,11 @@ static void UseSurfEffect_4(struct Task * task) objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2)); ObjectEventClearHeldMovementIfFinished(objectEvent); - ObjectEventSetHeldMovement(objectEvent, sub_80641C0(objectEvent->placeholder18)); + ObjectEventSetHeldMovement(objectEvent, sub_80641C0(objectEvent->movementDirection)); gFieldEffectArguments[0] = task->data[1]; gFieldEffectArguments[1] = task->data[2]; gFieldEffectArguments[2] = gPlayerAvatar.objectEventId; - objectEvent->mapobj_unk_1A = FieldEffectStart(FLDEFF_SURF_BLOB); + objectEvent->fieldEffectSpriteId = FieldEffectStart(FLDEFF_SURF_BLOB); task->data[0]++; } } @@ -2957,8 +2957,8 @@ static void UseSurfEffect_5(struct Task * task) { gPlayerAvatar.preventStep = FALSE; gPlayerAvatar.flags &= 0xdf; - ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(objectEvent->placeholder18)); - sub_80DC44C(objectEvent->mapobj_unk_1A, 1); + ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(objectEvent->movementDirection)); + sub_80DC44C(objectEvent->fieldEffectSpriteId, 1); UnfreezeObjectEvents(); ScriptContext2_Disable(); FieldEffectActiveListRemove(FLDEFF_USE_SURF); @@ -3151,8 +3151,8 @@ static void UseFlyEffect_3(struct Task * task) struct ObjectEvent * objectEvent = &gObjectEvents[gPlayerAvatar.objectEventId]; if (task->data[15] & 0x08) { - sub_80DC44C(objectEvent->mapobj_unk_1A, 2); - sub_80DC478(objectEvent->mapobj_unk_1A, 0); + sub_80DC44C(objectEvent->fieldEffectSpriteId, 2); + sub_80DC478(objectEvent->fieldEffectSpriteId, 0); } task->data[1] = sub_8087168(); task->data[0]++; @@ -3435,7 +3435,7 @@ static void FlyInEffect_1(struct Task * task) SetPlayerAvatarStateMask(0x01); if (task->data[15] & 0x08) { - sub_80DC44C(objectEvent->mapobj_unk_1A, 0); + sub_80DC44C(objectEvent->fieldEffectSpriteId, 0); } ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(2)); CameraObjectReset2(); @@ -3549,7 +3549,7 @@ static void FlyInEffect_7(struct Task * task) if (task->data[15] & 0x08) { state = 2; - sub_80DC44C(objectEvent->mapobj_unk_1A, 1); + sub_80DC44C(objectEvent->fieldEffectSpriteId, 1); } ObjectEventSetGraphicsId(objectEvent, GetPlayerAvatarGraphicsIdByStateId(state)); ObjectEventTurn(objectEvent, DIR_SOUTH); -- cgit v1.2.3 From 4df660dc76b5f35d2a89e0cb627180b79e9caa12 Mon Sep 17 00:00:00 2001 From: GriffinR Date: Wed, 4 Mar 2020 10:42:40 -0500 Subject: Add enums for help system text, label help context --- src/field_effect.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 9b2974f1f..b28063626 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -1232,7 +1232,7 @@ static bool8 FallWarpEffect_7(struct Task * task) { VarSet(VAR_TEMP_1, 1); SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_SURFING); - HelpSystem_SetSomeVariable2(22); + SetHelpContext(HELPCONTEXT_SURFING); } DestroyTask(FindTaskIdByFunc(Task_FallWarpFieldEffect)); return FALSE; @@ -2963,7 +2963,7 @@ static void UseSurfEffect_5(struct Task * task) ScriptContext2_Disable(); FieldEffectActiveListRemove(FLDEFF_USE_SURF); DestroyTask(FindTaskIdByFunc(Task_FldEffUseSurf)); - HelpSystem_SetSomeVariable2(22); + SetHelpContext(HELPCONTEXT_SURFING); } } -- cgit v1.2.3 From 19698ff65d8d576ecbb603c0421337237abffb81 Mon Sep 17 00:00:00 2001 From: PikalaxALT Date: Fri, 6 Mar 2020 11:34:18 -0500 Subject: Annotate undumped symbols in sym_ewram.txt --- src/field_effect.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/field_effect.c') diff --git a/src/field_effect.c b/src/field_effect.c index 49b48ed93..30ddf0a1b 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -32,6 +32,8 @@ #define subsprite_table(ptr) {.subsprites = ptr, .subspriteCount = (sizeof ptr) / (sizeof(struct Subsprite))} #define FIELD_EFFECT_COUNT 32 +EWRAM_DATA u32 gFieldEffectArguments[8] = {0}; + static u8 sFieldEffectActiveList[FIELD_EFFECT_COUNT]; static void FieldEffectActiveListAdd(u8 fldeff); -- cgit v1.2.3