diff options
Diffstat (limited to 'src')
39 files changed, 4144 insertions, 177 deletions
diff --git a/src/bg_regs.c b/src/bg_regs.c index d5879a862..ec884e4f7 100644 --- a/src/bg_regs.c +++ b/src/bg_regs.c @@ -25,7 +25,7 @@ vu16 *const gBGVOffsetRegs[] = }; const u16 gDISPCNTBGFlags[] = { DISPCNT_BG0_ON, DISPCNT_BG1_ON, DISPCNT_BG2_ON, DISPCNT_BG3_ON }; -const u16 gBLDCNTTarget2BGFlags[] = { BLDCNT_TGT2_BG0, BLDCNT_TGT2_BG1, BLDCNT_TGT2_BG2, BLDCNT_TGT2_BG3 }; +const u16 gOverworldBackgroundLayerFlags[] = { BLDCNT_TGT2_BG0, BLDCNT_TGT2_BG1, BLDCNT_TGT2_BG2, BLDCNT_TGT2_BG3 }; const u16 gBLDCNTTarget1BGFlags[] = { BLDCNT_TGT1_BG0, BLDCNT_TGT1_BG1, BLDCNT_TGT1_BG2, BLDCNT_TGT1_BG3 }; const u8 gBGControlRegOffsets[] = diff --git a/src/bike.c b/src/bike.c new file mode 100644 index 000000000..eaa4af2bd --- /dev/null +++ b/src/bike.c @@ -0,0 +1,426 @@ +#include "global.h" +#include "bike.h" +#include "field_player_avatar.h" +#include "metatile_behavior.h" +#include "event_object_movement.h" +#include "fieldmap.h" +#include "field_camera.h" +#include "overworld.h" +#include "constants/map_types.h" +#include "constants/songs.h" + +static u8 sub_80BD0D4(u8 *, u16, u16); +static void sub_80BD664(void); +static u8 sub_80BD4F0(u8, u8); +static u8 sub_80BD3A0(u8); +static u8 sub_80BD40C(struct ObjectEvent *, s16, s16, u8, u8); +static bool8 sub_80BD4B8(u8); +static void sub_80BD27C(u8); +static void sub_80BD28C(u8); +static void sub_80BD2C8(u8); +static void sub_80BD358(u8); +static void sub_80BD380(u8); +static u8 sub_80BD100(u8 *, u16, u16); +static u8 sub_80BD1C8(u8 *, u16, u16); +static u8 sub_80BD1E8(u8 *, u16, u16); + +static void (*const gUnknown_83E7CFC[])(u8) = +{ + sub_80BD27C, + sub_80BD28C, + sub_80BD2C8, + sub_80BD358, + sub_80BD380, +}; + +static u8 (*const gUnknown_83E7D10[])(u8 *, u16, u16) = +{ + sub_80BD100, + sub_80BD1C8, + sub_80BD1E8, +}; + +void MovePlayerOnBike(u8 direction, u16 newKeys, u16 heldKeys) +{ + gUnknown_83E7CFC[sub_80BD0D4(&direction, newKeys, heldKeys)](direction); +} + +static u8 sub_80BD0D4(u8 *direction, u16 newKeys, u16 heldKeys) +{ + return gUnknown_83E7D10[gPlayerAvatar.acroBikeState](direction, newKeys, heldKeys); +} + +static u8 sub_80BD100(u8 *r6, u16 sl, u16 sb) +{ + struct ObjectEvent *r4 = &gObjectEvents[gPlayerAvatar.objectEventId]; + u8 r7 = GetPlayerMovementDirection(); + + gPlayerAvatar.bikeFrameCounter = 0; + if (MetatileBehavior_IsCyclingRoadPullDownTile(r4->currentMetatileBehavior) == TRUE) + { + if (!JOY_HELD(B_BUTTON)) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING; + gPlayerAvatar.runningState = 2; + if (*r6 < 2) + return 3; + else + return 4; + } + else + { + if (*r6 != 0) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING; + gPlayerAvatar.runningState = 2; + return 4; + } + else + { + goto _080BD17E; // for matching purpose + } + } + } + else + { + if (*r6 == 0) + { + _080BD17E: + *r6 = r7; + gPlayerAvatar.runningState = 0; + return 0; + } + else + { + if (*r6 != r7 && gPlayerAvatar.runningState != 2) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_TURNING; + gPlayerAvatar.newDirBackup = *r6; + gPlayerAvatar.runningState = 0; + return sub_80BD0D4(r6, sl, sb); + } + else + { + gPlayerAvatar.runningState = 2; + return 2; + } + } + } +} + +static u8 sub_80BD1C8(u8 *r0, UNUSED u16 r1, UNUSED u16 r2) +{ + *r0 = gPlayerAvatar.newDirBackup; + gPlayerAvatar.runningState = 1; + gPlayerAvatar.acroBikeState = ACRO_STATE_NORMAL; + sub_80BD664(); + return 1; +} + +static u8 sub_80BD1E8(u8 *r6, u16 sb, u16 r8) +{ + u8 r5 = GetPlayerMovementDirection(); + u8 r1 = gPlayerAvatar.objectEventId; + if (MetatileBehavior_IsCyclingRoadPullDownTile(r1[gObjectEvents].currentMetatileBehavior) == TRUE) + { + if (*r6 != r5) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_TURNING; + gPlayerAvatar.newDirBackup = *r6; + gPlayerAvatar.runningState = 0; + return sub_80BD0D4(r6, sb, r8); + } + else + { + gPlayerAvatar.runningState = 2; + gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING; + if (*r6 < 2) + return 3; + else + return 4; + } + } + else + { + gPlayerAvatar.acroBikeState = ACRO_STATE_NORMAL; + if (*r6 == 0) + { + *r6 = r5; + gPlayerAvatar.runningState = 0; + return 0; + } + else + { + gPlayerAvatar.runningState = 2; + return 2; + } + } +} + +static void sub_80BD27C(u8 r0) +{ + PlayerFaceDirection(r0); +} + +static void sub_80BD28C(u8 r4) +{ + struct ObjectEvent *r5 = &gObjectEvents[gPlayerAvatar.objectEventId]; + + if (!sub_80BD4F0(r4, r5->currentMetatileBehavior)) + r4 = r5->movementDirection; + PlayerFaceDirection(r4); +} + +static void sub_80BD2C8(u8 r4) +{ + struct ObjectEvent *r5; + + r5 = &gObjectEvents[gPlayerAvatar.objectEventId]; + if (!sub_80BD4F0(r4, r5->currentMetatileBehavior)) + { + sub_80BD27C(r5->movementDirection); + } + else + { + u8 r1 = sub_80BD3A0(r4); + + if (r1 > 0 && r1 <= 11) + { + if (r1 == 6) + PlayerJumpLedge(r4); + else if (r1 != 5 && r1 != 6 && r1 != 7 && r1 != 8) + PlayerOnBikeCollide(r4); + } + else + { + + if (r1 == 14) + PlayerGoSpeed2(r4); + else if (PlayerIsMovingOnRockStairs(r4)) + PlayerGoSpeed2(r4); + else + PlayerRideWaterCurrent(r4); + } + } +} + +static void sub_80BD358(UNUSED u8 v) +{ + u8 r0 = sub_80BD3A0(1); + + if (r0 == 0) + sub_805C164(1); + else if (r0 == 6) + PlayerJumpLedge(1); +} + +static void sub_80BD380(u8 r4) +{ + if (sub_80BD3A0(r4) == 0) + PlayerGoSpeed1(r4); +} + +static u8 sub_80BD3A0(u8 r6) +{ + struct ObjectEvent *r4 = &gObjectEvents[gPlayerAvatar.objectEventId]; + s16 sp04, sp06; + u8 r0; + + sp04 = r4->currentCoords.x; + sp06 = r4->currentCoords.y; + MoveCoords(r6, &sp04, &sp06); + r0 = MapGridGetMetatileBehaviorAt(sp04, sp06); + return sub_80BD40C(r4, sp04, sp06, r6, r0); +} + +static u8 sub_80BD40C(struct ObjectEvent *r0, s16 r1, s16 r2, u8 r3, u8 r5) +{ + u8 r4 = CheckForObjectEventCollision(r0, r1, r2, r3, r5); + + if (r4 <= 4) + { + u8 r0 = MetatileBehavior_IsCrackedIce(r5); + if (r0 == TRUE) + return 14; + if (r4 == 0 && sub_80BD4B8(r5)) + r4 = 2; + } + return r4; +} + +bool8 sub_80BD460(u8 r0) +{ + if (sub_80BD4B8(r0)) + return TRUE; + if (gMapHeader.mapType != MAP_TYPE_INDOOR) + return FALSE; + else + return TRUE; +} + +bool32 IsRunningDisallowed(u8 metatileBehavior) +{ + if (!(gMapHeader.flags & MAP_ALLOW_RUN)) + return TRUE; + if (sub_80BD4B8(metatileBehavior) != TRUE) + return FALSE; + else + return TRUE; +} + +static bool8 sub_80BD4B8(u8 r4) +{ + if (MetatileBehavior_IsMB0A(r4)) + return TRUE; + if (!MetatileBehavior_ReturnFalse_9(r4)) + return FALSE; + if (PlayerGetZCoord() & 1) + return FALSE; + return TRUE; +} + +static bool8 sub_80BD4F0(u8 r0, u8 r4) +{ + if (r0 == DIR_EAST || r0 == DIR_WEST) + { + if (MetatileBehavior_IsIsolatedVerticalRail(r4) || MetatileBehavior_IsVerticalRail(r4)) + return FALSE; + } + else + { + if (MetatileBehavior_IsIsolatedHorizontalRail(r4) || MetatileBehavior_IsHorizontalRail(r4)) + return FALSE; + } + return TRUE; +} + +bool8 sub_80BD540(void) +{ + s16 sp00, sp02; + u8 r0; + + if (!(gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_UNDERWATER | PLAYER_AVATAR_FLAG_SURFING))) + { + PlayerGetDestCoords(&sp00, &sp02); + r0 = MapGridGetMetatileBehaviorAt(sp00, sp02); + if (!sub_80BD4B8(r0)) + return FALSE; + } + return TRUE; +} + +bool8 player_should_look_direction_be_enforced_upon_movement(void) +{ + if (TestPlayerAvatarFlags(PLAYER_AVATAR_STATE_UNDERWATER)) + { + if (MetatileBehavior_IsBumpySlope(gObjectEvents[gPlayerAvatar.objectEventId].currentMetatileBehavior)) + return FALSE; + } + return TRUE; +} + +void StartTransitionToFlipBikeState(u8 flags) +{ + gBikeCameraAheadPanback = FALSE; + if (gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE)) + { + SetPlayerAvatarTransitionFlags(PLAYER_AVATAR_FLAG_ON_FOOT); + Overworld_ClearSavedMusic(); + Overworld_PlaySpecialMapMusic(); + } + else + { + SetPlayerAvatarTransitionFlags(flags); + if (sub_8056124(MUS_CYCLING)) + { + Overworld_SetSavedMusic(MUS_CYCLING); + Overworld_ChangeMusicTo(MUS_CYCLING); + } + } +} + +void sub_80BD620(u32 directionHistory, u32 abStartSelectHistory) +{ + u8 i; + + gPlayerAvatar.acroBikeState = ACRO_STATE_NORMAL; + gPlayerAvatar.newDirBackup = 0; + gPlayerAvatar.bikeFrameCounter = 0; + gPlayerAvatar.bikeSpeed = SPEED_STANDING; + gPlayerAvatar.directionHistory = directionHistory; + gPlayerAvatar.abStartSelectHistory = abStartSelectHistory; + gPlayerAvatar.lastSpinTile = 0; + for (i = 0; i < NELEMS(gPlayerAvatar.dirTimerHistory); ++i) + gPlayerAvatar.dirTimerHistory[i] = 0; +} + +void Bike_UpdateBikeCounterSpeed(u8 counter) +{ + gPlayerAvatar.bikeFrameCounter = counter; + gPlayerAvatar.bikeSpeed = counter + (gPlayerAvatar.bikeFrameCounter >> 1); +} + +static void sub_80BD664(void) +{ + gPlayerAvatar.bikeFrameCounter = 0; + gPlayerAvatar.bikeSpeed = SPEED_STANDING; +} + +s16 GetPlayerSpeed(void) +{ + s16 exp[] = { 1, 2, 4 }; + + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_MACH_BIKE) + return exp[gPlayerAvatar.bikeFrameCounter]; + else if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_ACRO_BIKE) + return 3; + else if (gPlayerAvatar.flags & (PLAYER_AVATAR_FLAG_SURFING | PLAYER_AVATAR_FLAG_WATERING)) + return 2; + else + return 1; +} + +void Bike_HandleBumpySlopeJump(void) +{ + s16 x, y; + u8 tileBehavior; + + if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_ACRO_BIKE) + { + PlayerGetDestCoords(&x, &y); + tileBehavior = MapGridGetMetatileBehaviorAt(x, y); + if (MetatileBehavior_IsBumpySlope(tileBehavior)) + { + gPlayerAvatar.acroBikeState = ACRO_STATE_WHEELIE_STANDING; + nullsub_24(GetPlayerMovementDirection()); + } + } +} + +// R/S leftover + +// the struct below is used for checking button combinations of the last input so that the acro can potentially perform a side/turn jump. +// its possible that at some point Game Freak intended for the acro bike to have more complex tricks: but only the acro jump combinations can be seen in the final ROM. +struct BikeHistoryInputInfo +{ + u32 dirHistoryMatch; // the direction you need to press + u32 abStartSelectHistoryMatch; // the button you need to press + u32 dirHistoryMask; // mask applied so that way only the recent nybble (the recent input) is checked + u32 abStartSelectHistoryMask; // mask applied so that way only the recent nybble (the recent input) is checked + const u8 *dirTimerHistoryList; // list of timers to check for direction before the button+dir combination can be verified. + const u8 *abStartSelectHistoryList; // list of timers to check for buttons before the button+dir combination can be verified. + u32 direction; // direction to jump +}; + +// this is a list of timers to compare against later, terminated with 0. the only timer being compared against is 4 frames in this list. +static const u8 sAcroBikeJumpTimerList[] = {4, 0}; + +// this is a list of history inputs to do in order to do the check to retrieve a jump direction for acro bike. it seems to be an extensible list, so its possible that Game Freak may have intended for the Acro Bike to have more complex tricks at some point. The final list only has the acro jump. +static const struct BikeHistoryInputInfo sAcroBikeTricksList[] = +{ + // the 0xF is a mask performed with each byte of the array in order to perform the check on only the last entry of the history list, otherwise the check wouldn't work as there can be 0xF0 as opposed to 0x0F. + {DIR_SOUTH, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_SOUTH}, + {DIR_NORTH, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_NORTH}, + {DIR_WEST, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_WEST}, + {DIR_EAST, B_BUTTON, 0xF, 0xF, sAcroBikeJumpTimerList, sAcroBikeJumpTimerList, DIR_EAST}, +}; diff --git a/src/cable_club.c b/src/cable_club.c index bc41ca4f6..e75f1abf8 100644 --- a/src/cable_club.c +++ b/src/cable_club.c @@ -724,7 +724,7 @@ static void sub_8081624(void) void CB2_ReturnFromCableClubBattle(void) { gBattleTypeFlags &= (u16)~BATTLE_TYPE_20; - sub_8055DB8(); + Overworld_ResetMapMusic(); LoadPlayerParty(); SavePlayerBag(); Special_UpdateTrainerFansAfterLinkBattle(); @@ -750,7 +750,7 @@ void CB2_ReturnFromCableClubBattle(void) } else { - gMain.savedCallback = c2_8056854; + gMain.savedCallback = CB2_ReturnToFieldFromMultiplayer; } SetMainCallback2(CB2_SetUpSaveAfterLinkBattle); } @@ -767,7 +767,7 @@ void CleanupLinkRoomState(void) void ExitLinkRoom(void) { - sub_8057F5C(); + QueueExitLinkRoomKey(); } static void Task_EnterCableClubSeat(u8 taskId) diff --git a/src/credits.c b/src/credits.c index 4d7bbd67b..12240c98f 100644 --- a/src/credits.c +++ b/src/credits.c @@ -1,6 +1,7 @@ #include "global.h" #include "malloc.h" #include "bg.h" +#include "credits.h" #include "palette.h" #include "gpu_regs.h" #include "task.h" @@ -563,94 +564,81 @@ static const struct SpriteTemplate sGroundSpriteTemplate_Static = { }; static const struct CreditsOverworldCmd sOverworldCmd_Route23[] = { - { 0x00fe, MAP_GROUP(ROUTE23), MAP_NUM(ROUTE23) }, - { 0x000b, 0x006b, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(ROUTE23, 11, 107, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_ViridianCity[] = { - { 0x00fe, MAP_GROUP(VIRIDIAN_CITY), MAP_NUM(VIRIDIAN_CITY) }, - { 0x001e, 0x0022, 0x0001 }, - { 0x0000, 0xffff, 0x0500 }, // Scroll up - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(VIRIDIAN_CITY, 30, 34, 1), + CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_PewterCity[] = { - { 0x00fe, MAP_GROUP(PEWTER_CITY), MAP_NUM(PEWTER_CITY) }, - { 0x0014, 0x001a, 0x0001 }, - { 0x0000, 0xffff, 0x0500 }, // Scroll up - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(PEWTER_CITY, 20, 26, 1), + CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_CeruleanCity[] = { - { 0x00fe, MAP_GROUP(CERULEAN_CITY), MAP_NUM(CERULEAN_CITY) }, - { 0x0008, 0x0006, 0x0001 }, - { 0x0001, 0x0001, 0x0500 }, // Scroll right and down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(CERULEAN_CITY, 8, 6, 1), + CREDITSOVWLDSCROLL(1, 1, 0x0500), // Scroll right and down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_Route25[] = { - { 0x00fe, MAP_GROUP(ROUTE25), MAP_NUM(ROUTE25) }, - { 0x0019, 0x0006, 0x0001 }, - { 0x0001, 0x0000, 0x0500 }, // Scroll right - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(ROUTE25, 25, 6, 1), + CREDITSOVWLDSCROLL(1, 0, 0x0500), // Scroll right + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_VermilionCity[] = { - { 0x00fe, MAP_GROUP(VERMILION_CITY), MAP_NUM(VERMILION_CITY) }, - { 0x0009, 0x0007, 0x0001 }, - { 0x0001, 0x0001, 0x0500 }, // Scroll right and down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(VERMILION_CITY, 9, 7, 1), + CREDITSOVWLDSCROLL(1, 1, 0x0500), // Scroll right and down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_Route10[] = { - { 0x00fe, MAP_GROUP(ROUTE10), MAP_NUM(ROUTE10) }, - { 0x000b, 0x0044, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(ROUTE10, 11, 68, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_CeladonCity[] = { - { 0x00fe, MAP_GROUP(CELADON_CITY), MAP_NUM(CELADON_CITY) }, - { 0x0030, 0x0010, 0x0001 }, - { 0xffff, 0x0000, 0x0500 }, // Scroll left - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(CELADON_CITY, 48, 16, 1), + CREDITSOVWLDSCROLL(-1, 0, 0x0500), // Scroll left + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_SaffronCity[] = { - { 0x00fe, MAP_GROUP(SAFFRON_CITY), MAP_NUM(SAFFRON_CITY) }, - { 0x0027, 0x0005, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(SAFFRON_CITY, 39, 5, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_Route17[] = { - { 0x00fe, MAP_GROUP(ROUTE17), MAP_NUM(ROUTE17) }, - { 0x0007, 0x002b, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(ROUTE17, 7, 43, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_FuchsiaCity[] = { - { 0x00fe, MAP_GROUP(FUCHSIA_CITY), MAP_NUM(FUCHSIA_CITY) }, - { 0x001c, 0x0005, 0x0001 }, - { 0x0000, 0x0001, 0x0500 }, // Scroll down - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(FUCHSIA_CITY, 28, 5, 1), + CREDITSOVWLDSCROLL(0, 1, 0x0500), // Scroll down + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_CinnabarIsland[] = { - { 0x00fe, MAP_GROUP(CINNABAR_ISLAND), MAP_NUM(CINNABAR_ISLAND) }, - { 0x000d, 0x0011, 0x0001 }, - { 0x0000, 0xffff, 0x0500 }, // Scroll up - { 0x00fd, 0x00fd, 0x00fd } + CREDITSOVWLDLOADMAP(CINNABAR_ISLAND, 13, 17, 1), + CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up + CREDITSOVWLDEND }; static const struct CreditsOverworldCmd sOverworldCmd_Route21[] = { - { 0x00fe, MAP_GROUP(ROUTE21_NORTH), MAP_NUM(ROUTE21_NORTH) }, - { 0x0008, 0x0014, 0x0001 }, - { 0x0000, 0xffff, 0x0500 }, // Scroll up - { 0x00fd, 0x00fd, 0x00fd }, + CREDITSOVWLDLOADMAP(ROUTE21_NORTH, 8, 20, 1), + CREDITSOVWLDSCROLL(0, -1, 0x0500), // Scroll up + CREDITSOVWLDEND, }; static const struct CreditsOverworldCmd *const sOverworldMapScenes[] = { diff --git a/src/daycare.c b/src/daycare.c index e07c2a234..1e50a7c09 100644 --- a/src/daycare.c +++ b/src/daycare.c @@ -1766,7 +1766,7 @@ static void Task_EggHatch(u8 taskID) { CleanupOverworldWindowsAndTilemaps(); SetMainCallback2(CB2_EggHatch_0); - gFieldCallback = FieldCallback_ReturnToEventScript2; + gFieldCallback = FieldCB_ContinueScriptHandleMusic; DestroyTask(taskID); } } diff --git a/src/diploma.c b/src/diploma.c index f702eebd5..5c653d071 100644 --- a/src/diploma.c +++ b/src/diploma.c @@ -193,7 +193,7 @@ static void Task_DiplomaReturnToOverworld(u8 taskId) DestroyTask(taskId); FreeAllWindowBuffers(); FREE_AND_SET_NULL(gDiploma); - SetMainCallback2(CB2_Overworld); + SetMainCallback2(sub_80568FC); } static void DiplomaBgInit(void) diff --git a/src/easy_chat_2.c b/src/easy_chat_2.c index 4b3c70b67..948b7c39f 100644 --- a/src/easy_chat_2.c +++ b/src/easy_chat_2.c @@ -279,7 +279,7 @@ void ShowEasyChatScreen(void) default: return; } - DoEasyChatScreen(gSpecialVar_0x8004, words, sub_80568C4); + DoEasyChatScreen(gSpecialVar_0x8004, words, CB2_ReturnToFieldContinueScript); } static const u16 sECPhrase_MysteryEventIsExciting[] = { diff --git a/src/event_data.c b/src/event_data.c index f16267c98..c012a4a59 100644 --- a/src/event_data.c +++ b/src/event_data.c @@ -38,7 +38,7 @@ void InitEventData(void) memset(sSpecialFlags, 0, SPECIAL_FLAGS_COUNT); } -void sub_806E110(void) +void ClearTempFieldEventData(void) { memset(gSaveBlock1Ptr->flags, 0, 4); memset(gSaveBlock1Ptr->vars, 0, 16 * 2); diff --git a/src/field_camera.c b/src/field_camera.c index 40ab8f464..f383b2a27 100644 --- a/src/field_camera.c +++ b/src/field_camera.c @@ -7,7 +7,7 @@ #include "new_menu_helpers.h" #include "overworld.h" -EWRAM_DATA bool8 gUnusedBikeCameraAheadPanback = FALSE; +EWRAM_DATA bool8 gBikeCameraAheadPanback = FALSE; // Static type declarations struct FieldCameraOffset @@ -531,7 +531,7 @@ static void CameraPanningCB_PanAhead(void) { u8 var; - if (gUnusedBikeCameraAheadPanback == FALSE) + if (gBikeCameraAheadPanback == FALSE) { InstallCameraPanAheadCallback(); } diff --git a/src/field_effect.c b/src/field_effect.c index b59ce5a6b..c0d7d3463 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -2064,7 +2064,7 @@ static void EscapeRopeFieldEffect_Step1(struct Task * task) if (data[4] == 1 && !gPaletteFade.active && BGMusicStopped() == TRUE) { SetObjectEventDirection(playerObj, task->data[15]); - sub_80555E0(); + SetWarpDestinationToEscapeWarp(); WarpIntoMap(); gFieldCallback = FieldCallback_EscapeRopeExit; SetMainCallback2(CB2_LoadMap); @@ -2331,7 +2331,7 @@ static void TeleportFieldEffectTask4(struct Task * task) { if (BGMusicStopped() == TRUE) { - copy_saved_warp3_bank_and_enter_x_to_warp1(); + SetWarpDestinationToLastHealLocation(); WarpIntoMap(); SetMainCallback2(CB2_LoadMap); gFieldCallback = FieldCallback_TeleportIn; diff --git a/src/field_fadetransition.c b/src/field_fadetransition.c index 03190c095..bf5ab0ab3 100644 --- a/src/field_fadetransition.c +++ b/src/field_fadetransition.c @@ -94,7 +94,7 @@ void FadeInFromBlack(void) void WarpFadeOutScreen(void) { - const struct MapHeader *header = warp1_get_mapheader(); + const struct MapHeader *header = GetDestinationWarpMapHeader(); if (header->regionMapSectionId != gMapHeader.regionMapSectionId && MapHasPreviewScreen(header->regionMapSectionId, MPS_TYPE_CAVE)) FadeScreen(FADE_TO_BLACK, 0); else @@ -113,7 +113,7 @@ void WarpFadeOutScreen(void) static void sub_807DC70(void) { - switch (MapTransitionIsEnter(GetCurrentMapType(), warp1_get_mapheader()->mapType)) + switch (MapTransitionIsEnter(GetCurrentMapType(), GetDestinationWarpMapHeader()->mapType)) { case FALSE: FadeScreen(FADE_TO_BLACK, 3); @@ -152,7 +152,7 @@ static void task0A_asap_script_env_2_enable_and_set_ctx_running(u8 taskId) } } -void FieldCallback_ReturnToEventScript2(void) +void FieldCB_ContinueScriptHandleMusic(void) { ScriptContext2_Enable(); Overworld_PlaySpecialMapMusic(); @@ -160,7 +160,7 @@ void FieldCallback_ReturnToEventScript2(void) CreateTask(task0A_asap_script_env_2_enable_and_set_ctx_running, 10); } -void sub_807DD44(void) +void FieldCB_ContinueScript(void) { ScriptContext2_Enable(); FadeInFromBlack(); @@ -193,7 +193,7 @@ static void task_mpl_807DD60(u8 taskId) } } -void FieldCB_ReturnToFieldWiredLink(void) +void FieldCB_ReturnToFieldCableLink(void) { ScriptContext2_Enable(); Overworld_PlaySpecialMapMusic(); @@ -284,7 +284,7 @@ static void sub_807DF4C(bool8 a0) FadeInFromBlack(); } -void FieldCB_UnionRoomWarp(void) +void FieldCB_DefaultWarpExit(void) { Overworld_PlaySpecialMapMusic(); sub_8111CF0(); @@ -292,7 +292,7 @@ void FieldCB_UnionRoomWarp(void) ScriptContext2_Enable(); } -void sub_807DF7C(void) +void FieldCB_WarpExitFadeFromBlack(void) { Overworld_PlaySpecialMapMusic(); sub_8111CF0(); @@ -491,7 +491,7 @@ void FadeTransition_FadeInOnReturnToStartMenu(void) ScriptContext2_Enable(); } -bool8 FieldCB2_ReturnToStartMenuInit(void) +bool8 FieldCB_ReturnToFieldOpenStartMenu(void) { SetUpReturnToStartMenu(); return FALSE; @@ -535,7 +535,7 @@ void DoWarp(void) WarpFadeOutScreen(); PlayRainStoppingSoundEffect(); PlaySE(SE_KAIDAN); - gFieldCallback = FieldCB_UnionRoomWarp; + gFieldCallback = FieldCB_DefaultWarpExit; CreateTask(sub_807E718, 10); } @@ -545,7 +545,7 @@ void DoDiveWarp(void) TryFadeOutOldMapMusic(); WarpFadeOutScreen(); PlayRainStoppingSoundEffect(); - gFieldCallback = FieldCB_UnionRoomWarp; + gFieldCallback = FieldCB_DefaultWarpExit; CreateTask(sub_807E718, 10); } @@ -560,7 +560,7 @@ void sub_807E4A0(u16 metatileBehavior, u16 delay) void DoDoorWarp(void) { ScriptContext2_Enable(); - gFieldCallback = FieldCB_UnionRoomWarp; + gFieldCallback = FieldCB_DefaultWarpExit; CreateTask(sub_807E80C, 10); } @@ -574,7 +574,7 @@ void sub_807E500(void) void DoUnionRoomWarp(void) { ScriptContext2_Enable(); - gFieldCallback = FieldCB_UnionRoomWarp; + gFieldCallback = FieldCB_DefaultWarpExit; CreateTask(Task_TeleportWarp, 10); } @@ -833,7 +833,7 @@ static void sub_807E980(u8 taskId) data[0]++; break; default: - gFieldCallback = FieldCB_UnionRoomWarp; + gFieldCallback = FieldCB_DefaultWarpExit; WarpIntoMap(); SetMainCallback2(CB2_LoadMap); DestroyTask(taskId); diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c index 481e55578..6b51e7bc2 100644 --- a/src/field_player_avatar.c +++ b/src/field_player_avatar.c @@ -1152,7 +1152,7 @@ u8 GetPlayerAvatarGraphicsIdByStateIdAndGender(u8 state, u8 gender) return sPlayerAvatarGfxIds[state][gender]; } -u8 GetHoennLinkPartnerGraphicsIdByGender(u8 gender) +u8 GetRSAvatarGraphicsIdByGender(u8 gender) { return sHoennLinkPartnerGfxIds[gender]; } @@ -1350,7 +1350,7 @@ void sub_805CC2C(u8 direction) sub_8150498(2); } -void nullsub_24(void) +void nullsub_24(u8 direction) { } diff --git a/src/field_screen_effect.c b/src/field_screen_effect.c index a12b57b24..22043ed2d 100644 --- a/src/field_screen_effect.c +++ b/src/field_screen_effect.c @@ -360,7 +360,7 @@ static void Task_BarnDoorWipeChild(u8 taskId) #undef DIR_WIPE_OUT #undef tChildOffset -static bool8 sub_807F3A4(u8 taskId, const u8 *text, u8 x, u8 y) +static bool8 PrintWhiteOutRecoveryMessage(u8 taskId, const u8 *text, u8 x, u8 y) { u8 windowId = gTasks[taskId].data[1]; @@ -385,7 +385,7 @@ static bool8 sub_807F3A4(u8 taskId, const u8 *text, u8 x, u8 y) return FALSE; } -static void sub_807F45C(u8 taskId) +static void Task_RushInjuredPokemonToCenter(u8 taskId) { u8 windowId; const struct HealLocation *loc; @@ -399,7 +399,7 @@ static void sub_807F45C(u8 taskId) FillWindowPixelBuffer(windowId, PIXEL_FILL(0)); PutWindowTilemap(windowId); CopyWindowToVram(windowId, 3); - loc = GetHealLocationPointer(1); + loc = GetHealLocation(1); if (gSaveBlock1Ptr->lastHealLocation.mapGroup == loc->group && gSaveBlock1Ptr->lastHealLocation.mapNum == loc->map && gSaveBlock1Ptr->lastHealLocation.warpId == -1 @@ -410,14 +410,14 @@ static void sub_807F45C(u8 taskId) gTasks[taskId].data[0] = 1; break; case 1: - if (sub_807F3A4(taskId, gUnknown_841B554, 2, 8)) + if (PrintWhiteOutRecoveryMessage(taskId, gText_PlayerScurriedToCenter, 2, 8)) { ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], 2); ++gTasks[taskId].data[0]; } break; case 4: - if (sub_807F3A4(taskId, gUnknown_841B5B6, 2, 8)) + if (PrintWhiteOutRecoveryMessage(taskId, gText_PlayerScurriedBackHome, 2, 8)) { ObjectEventTurn(&gObjectEvents[gPlayerAvatar.objectEventId], 2); ++gTasks[taskId].data[0]; @@ -450,12 +450,12 @@ static void sub_807F45C(u8 taskId) } } -void sub_807F5F0(void) +void FieldCB_RushInjuredPokemonToCenter(void) { u8 taskId; ScriptContext2_Enable(); palette_bg_faded_fill_black(); - taskId = CreateTask(sub_807F45C, 10); + taskId = CreateTask(Task_RushInjuredPokemonToCenter, 10); gTasks[taskId].data[0] = 0; } diff --git a/src/field_specials.c b/src/field_specials.c index 59c026b78..657c80a40 100644 --- a/src/field_specials.c +++ b/src/field_specials.c @@ -108,7 +108,7 @@ void ForcePlayerOntoBike(void) Overworld_ChangeMusicTo(MUS_CYCLING); } -void nullsub_74(void) +void ResetCyclingRoadChallengeData(void) { } @@ -840,9 +840,9 @@ static const u8 sElevatorWindowAnimDuration[] = { void GetElevatorFloor(void) { u16 floor = 4; - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(SILPH_CO_1F): floor = 4; @@ -888,9 +888,9 @@ void GetElevatorFloor(void) break; } } - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(CELADON_CITY_DEPARTMENT_STORE_1F): floor = 4; @@ -909,9 +909,9 @@ void GetElevatorFloor(void) break; } } - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(TRAINER_TOWER_1F): case MAP_NUM(TRAINER_TOWER_2F): @@ -937,9 +937,9 @@ u16 InitElevatorFloorSelectMenuPos(void) sElevatorScroll = 0; sElevatorCursorPos = 0; - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(ROCKET_HIDEOUT_B1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(SILPH_CO_11F): sElevatorScroll = 0; @@ -999,9 +999,9 @@ u16 InitElevatorFloorSelectMenuPos(void) break; } } - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(CELADON_CITY_DEPARTMENT_STORE_1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(CELADON_CITY_DEPARTMENT_STORE_5F): sElevatorScroll = 0; @@ -1025,9 +1025,9 @@ u16 InitElevatorFloorSelectMenuPos(void) break; } } - if (gSaveBlock1Ptr->warp2.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)) + if (gSaveBlock1Ptr->dynamicWarp.mapGroup == MAP_GROUP(TRAINER_TOWER_1F)) { - switch (gSaveBlock1Ptr->warp2.mapNum) + switch (gSaveBlock1Ptr->dynamicWarp.mapNum) { case MAP_NUM(TRAINER_TOWER_1F): case MAP_NUM(TRAINER_TOWER_2F): @@ -2037,10 +2037,10 @@ const u16 sPokeCenter1FMaps[] = { MAP_UNDEFINED }; -bool8 sub_80CC87C(void) +bool8 UsedPokemonCenterWarp(void) { s32 i; - u16 mapno = (gUnknown_2031DB4.mapGroup << 8) + gUnknown_2031DB4.mapNum; + u16 mapno = (gLastUsedWarp.mapGroup << 8) + gLastUsedWarp.mapNum; for (i = 0; sPokeCenter1FMaps[i] != MAP_UNDEFINED; i++) { if (sPokeCenter1FMaps[i] == mapno) diff --git a/src/field_tasks.c b/src/field_tasks.c index 6bd4b6f46..4c7b93f20 100644 --- a/src/field_tasks.c +++ b/src/field_tasks.c @@ -63,7 +63,7 @@ static void Task_RunTimeBasedEvents(u8 taskId) { if (gQuestLogState != 2 && gQuestLogState != 3) { - sub_8056078(&data[1], &data[2]); + UpdateAmbientCry(&data[1], &data[2]); } } } diff --git a/src/fieldmap.c b/src/fieldmap.c index 53a97629f..60c6f3dae 100644 --- a/src/fieldmap.c +++ b/src/fieldmap.c @@ -370,7 +370,7 @@ union Block s32 xprime; \ s32 yprime; \ \ - struct MapLayout *mapLayout = gMapHeader.mapLayout; \ + const struct MapLayout *mapLayout = gMapHeader.mapLayout; \ \ xprime = x - 7; \ xprime += 8 * mapLayout->borderWidth; \ @@ -485,7 +485,7 @@ void MapGridSetMetatileImpassabilityAt(s32 x, s32 y, bool32 arg2) } } -u32 GetBehaviorByMetatileIdAndMapLayout(struct MapLayout *mapLayout, u16 metatile, u8 attr) +u32 GetBehaviorByMetatileIdAndMapLayout(const struct MapLayout *mapLayout, u16 metatile, u8 attr) { u32 * attributes; @@ -732,7 +732,7 @@ bool8 CameraMove(s32 x, s32 y) old_y = gSaveBlock1Ptr->pos.y; connection = sub_8059600(direction, gSaveBlock1Ptr->pos.x, gSaveBlock1Ptr->pos.y); sub_80594AC(connection, direction, x, y); - sub_8055864(connection->mapGroup, connection->mapNum); + LoadMapFromCameraTransition(connection->mapGroup, connection->mapNum); gCamera.active = TRUE; gCamera.x = old_x - gSaveBlock1Ptr->pos.x; gCamera.y = old_y - gSaveBlock1Ptr->pos.y; diff --git a/src/heal_location.c b/src/heal_location.c index a8ac8cb46..ae02c7844 100644 --- a/src/heal_location.c +++ b/src/heal_location.c @@ -50,7 +50,7 @@ static const struct HealLocation * GetHealLocationPointerFromMapGroupAndNum(u16 return &sSpawnPoints[i - 1]; } -const struct HealLocation * GetHealLocationPointer(u32 idx) +const struct HealLocation * GetHealLocation(u32 idx) { if (idx == 0) return NULL; diff --git a/src/item_use.c b/src/item_use.c index df3dbaceb..af3243678 100644 --- a/src/item_use.c +++ b/src/item_use.c @@ -268,7 +268,7 @@ void FieldUseFunc_MachBike(u8 taskId) || MetatileBehavior_IsIsolatedVerticalRail(behavior) == TRUE || MetatileBehavior_IsIsolatedHorizontalRail(behavior) == TRUE) sub_80A10C4(taskId, gTasks[taskId].data[3], 2, gUnknown_8416451); - else if (sub_8055C9C() == TRUE && !sub_80BD540()) + else if (Overworld_IsBikingAllowed() == TRUE && !sub_80BD540()) { sItemUseOnFieldCB = ItemUseOnFieldCB_Bicycle; sub_80A103C(taskId); @@ -618,7 +618,7 @@ static void sub_80A1B48(u8 taskId) bool8 CanUseEscapeRopeOnCurrMap(void) { - if (gMapHeader.escapeRope & 1) + if (gMapHeader.flags & MAP_ALLOW_ESCAPE_ROPE) return TRUE; else return FALSE; diff --git a/src/itemfinder.c b/src/itemfinder.c index 5d6950acc..51a670b0f 100644 --- a/src/itemfinder.c +++ b/src/itemfinder.c @@ -15,7 +15,7 @@ static void Task_NoResponse_CleanUp(u8 taskId); static void Task_ItemfinderResponseSoundsAndAnims(u8 taskId); static void Task_ItemfinderUnderfootSoundsAndAnims(u8 taskId); -static bool8 HiddenItemIsWithinRangeOfPlayer(struct MapEvents * events, u8 taskId); +static bool8 HiddenItemIsWithinRangeOfPlayer(const struct MapEvents * events, u8 taskId); static void SetUnderfootHiddenItem(u8 taskId, u32 hiddenItem); static void SetNormalHiddenItem(u8 taskId); static void FindHiddenItemsInConnectedMaps(u8 taskId); @@ -199,7 +199,7 @@ static void Task_ItemfinderUnderfootSoundsAndAnims(u8 taskId) tDingTimer++; } -static bool8 HiddenItemIsWithinRangeOfPlayer(struct MapEvents * events, u8 taskId) +static bool8 HiddenItemIsWithinRangeOfPlayer(const struct MapEvents * events, u8 taskId) { s16 x, y, i, dx, dy; PlayerGetDestCoords(&x, &y); @@ -284,7 +284,7 @@ static void SetNormalHiddenItem(u8 taskId) } } -static bool8 HiddenItemAtPos(struct MapEvents * events, s16 x, s16 y) +static bool8 HiddenItemAtPos(const struct MapEvents * events, s16 x, s16 y) { u8 bgEventCount = events->bgEventCount; struct BgEvent * bgEvents = events->bgEvents; diff --git a/src/learn_move.c b/src/learn_move.c index 8a2f5781b..8cf10cffa 100644 --- a/src/learn_move.c +++ b/src/learn_move.c @@ -286,7 +286,7 @@ static void Task_InitMoveRelearnerMenu(u8 taskId) if (!gPaletteFade.active) { SetMainCallback2(CB2_MoveRelearner_Init); - gFieldCallback = FieldCallback_ReturnToEventScript2; + gFieldCallback = FieldCB_ContinueScriptHandleMusic; DestroyTask(taskId); } } diff --git a/src/link_rfu_2.c b/src/link_rfu_2.c index 2259e9214..15ffb4813 100644 --- a/src/link_rfu_2.c +++ b/src/link_rfu_2.c @@ -201,7 +201,7 @@ void ResetLinkRfuGFLayer(void) } ResetSendDataManager(&Rfu.cmd_8800_sendbuf); RFU_queue_20_70_reset(&Rfu.unk_124); - RFU_queue_40_14_reset(&Rfu.unk_9e8); + RFU_queue_40_14_reset(&Rfu.sendQueue); CpuFill16(0, gSendCmd, sizeof gSendCmd); CpuFill16(0, gRecvCmds, sizeof gRecvCmds); CpuFill16(0, gLinkPlayers, sizeof gLinkPlayers); @@ -659,7 +659,7 @@ static void sub_80F906C(void) } if (Rfu.unk_c3c == 0) { - RFU_queue_40_14_send(&Rfu.unk_9e8, Rfu.unk_4c); + RFU_queue_40_14_send(&Rfu.sendQueue, Rfu.unk_4c); RFU_queue_2_14_recv(&Rfu.unk_c1c, Rfu.unk_4c); } } @@ -881,7 +881,7 @@ static bool32 RfuProcessEnqueuedRecvBlock(void) Rfu.unk_cd0--; CallRfuFunc(); sub_80F94BC(gSendCmd, sp48); - RFU_queue_40_14_recv(&Rfu.unk_9e8, sp48); + RFU_queue_40_14_recv(&Rfu.sendQueue, sp48); for (i = 0; i < CMD_LENGTH - 1; i++) gSendCmd[i] = 0; } @@ -909,7 +909,7 @@ static void HandleSendFailure(u8 unused, u32 flags) j++;j--; // Needed to match; } - RFU_queue_40_14_recv(&Rfu.unk_9e8, sResendBlock8); + RFU_queue_40_14_recv(&Rfu.sendQueue, sResendBlock8); Rfu.cmd_8800_sendbuf.failedFlags |= (1 << i); } flags >>= 1; @@ -1853,11 +1853,11 @@ static void RfuCheckErrorStatus(void) gWirelessCommType = 2; SetMainCallback2(CB2_LinkError); gMain.savedCallback = CB2_LinkError; - SetLinkErrorFromRfu((Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.unk_124.count, Rfu.unk_9e8.count, RfuGetErrorStatus() == 2); + SetLinkErrorFromRfu((Rfu.linkman_msg << 16) | (Rfu.linkman_param[0] << 8) | Rfu.linkman_param[1], Rfu.unk_124.count, Rfu.sendQueue.count, RfuGetErrorStatus() == 2); Rfu.errorState = 2; CloseLink(); } - else if (Rfu.unk_9e8.full == 1 || Rfu.unk_124.full == 1) + else if (Rfu.sendQueue.full == 1 || Rfu.unk_124.full == 1) { if (lman.childClockSlave_flag) rfu_LMAN_requestChangeAgbClockMaster(); @@ -2851,7 +2851,7 @@ static const char gUnknown_843EEA8[][8] = { static u32 sub_80FC44C(void) { - return Rfu.unk_9e8.count; + return Rfu.sendQueue.count; } u32 GetRfuRecvQueueLength(void) diff --git a/src/link_rfu_3.c b/src/link_rfu_3.c index d3f6e93db..8382f1dab 100644 --- a/src/link_rfu_3.c +++ b/src/link_rfu_3.c @@ -184,7 +184,7 @@ void RFU_queue_20_70_reset(struct UnkRfuStruct_2_Sub_124 *queue) queue->full = 0; } -void RFU_queue_40_14_reset(struct UnkRfuStruct_2_Sub_9e8 *ptr) +void RFU_queue_40_14_reset(struct RfuSendQueue *ptr) { s32 i; s32 j; @@ -260,7 +260,7 @@ void RFU_queue_20_70_recv(struct UnkRfuStruct_2_Sub_124 *queue, u8 *data) } } -void RFU_queue_40_14_recv(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *data) +void RFU_queue_40_14_recv(struct RfuSendQueue *queue, u8 *data) { s32 i; u16 imeBak; @@ -325,7 +325,7 @@ bool8 RFU_queue_20_70_send(struct UnkRfuStruct_2_Sub_124 *queue, u8 *dest) return TRUE; } -bool8 RFU_queue_40_14_send(struct UnkRfuStruct_2_Sub_9e8 *queue, u8 *dest) +bool8 RFU_queue_40_14_send(struct RfuSendQueue *queue, u8 *dest) { s32 i; u16 imeBak; diff --git a/src/load_save.c b/src/load_save.c index 7ab28ffc3..9dff59928 100644 --- a/src/load_save.c +++ b/src/load_save.c @@ -127,24 +127,24 @@ void MoveSaveBlocks_ResetHeap(void) gSaveBlock2Ptr->encryptionKey = encryptionKey; } -u32 sav2_x1_query_bit1(void) +u32 UseContinueGameWarp(void) { return gSaveBlock2Ptr->specialSaveWarpFlags & CONTINUE_GAME_WARP; } -void sav2_x9_clear_bit1(void) +void ClearContinueGameWarpStatus(void) { gSaveBlock2Ptr->specialSaveWarpFlags &= ~CONTINUE_GAME_WARP; } -void sub_804C1AC(void) +void SetContinueGameWarpStatus(void) { gSaveBlock2Ptr->specialSaveWarpFlags |= CONTINUE_GAME_WARP; } void SetContinueGameWarpStatusToDynamicWarp(void) { - sub_8055778(0); + SetContinueGameWarpToDynamicWarp(0); gSaveBlock2Ptr->specialSaveWarpFlags |= CONTINUE_GAME_WARP; } @@ -286,7 +286,7 @@ void ApplyNewEncryptionKeyToAllEncryptedData(u32 encryptionKey) for(i = 0; i < NUM_TOWER_CHALLENGE_TYPES; i++) ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->trainerTower[i].bestTime, encryptionKey); - sub_8054F38(encryptionKey); + ApplyNewEncryptionKeyToGameStats(encryptionKey); ApplyNewEncryptionKeyToBagItems_(encryptionKey); ApplyNewEncryptionKeyToBerryPowder(encryptionKey); ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->money, encryptionKey); diff --git a/src/map_name_popup.c b/src/map_name_popup.c index 10e549cbd..87df371ce 100644 --- a/src/map_name_popup.c +++ b/src/map_name_popup.c @@ -18,7 +18,7 @@ static u16 MapNamePopupCreateWindow(bool32 palIntoFadedBuffer); static void MapNamePopupPrintMapNameOnWindow(u16 windowId); static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 flags); -void CreateMapNamePopupIfNotAlreadyRunning(bool32 palIntoFadedBuffer) +void ShowMapNamePopup(bool32 palIntoFadedBuffer) { u8 taskId; if (FlagGet(FLAG_SPECIAL_FLAG_0x4000) != TRUE && !(gQuestLogState == 2 || gQuestLogState == 3)) @@ -151,9 +151,9 @@ static u16 MapNamePopupCreateWindow(bool32 palintoFadedBuffer) }; u16 windowId; u16 r6 = 0x01D; - if (gMapHeader.flags != 0) + if (gMapHeader.floorNum != 0) { - if (gMapHeader.flags != 0x7F) + if (gMapHeader.floorNum != 0x7F) { windowTemplate.width += 5; r6 = 0x027; @@ -187,29 +187,29 @@ static void MapNamePopupPrintMapNameOnWindow(u16 windowId) u32 maxWidth = 112; u32 xpos; u8 *ptr = GetMapName(mapName, gMapHeader.regionMapSectionId, 0); - if (gMapHeader.flags != 0) + if (gMapHeader.floorNum != 0) { - ptr = MapNamePopupAppendFloorNum(ptr, gMapHeader.flags); - maxWidth = gMapHeader.flags != 0x7F ? 152 : 176; + ptr = MapNamePopupAppendFloorNum(ptr, gMapHeader.floorNum); + maxWidth = gMapHeader.floorNum != 0x7F ? 152 : 176; } xpos = (maxWidth - GetStringWidth(2, mapName, -1)) / 2; FillWindowPixelBuffer(windowId, PIXEL_FILL(1)); AddTextPrinterParameterized(windowId, 2, mapName, xpos, 2, 0xFF, NULL); } -static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 flags) +static u8 *MapNamePopupAppendFloorNum(u8 *dest, s8 floorNum) { - if (flags == 0) + if (floorNum == 0) return dest; *dest++ = CHAR_SPACE; - if (flags == 0x7F) + if (floorNum == 0x7F) return StringCopy(dest, gUnknown_841D18D); - if (flags < 0) + if (floorNum < 0) { *dest++ = CHAR_B; - flags *= -1; + floorNum *= -1; } - dest = ConvertIntToDecimalStringN(dest, flags, STR_CONV_MODE_LEFT_ALIGN, 2); + dest = ConvertIntToDecimalStringN(dest, floorNum, STR_CONV_MODE_LEFT_ALIGN, 2); *dest++ = CHAR_F; *dest = EOS; return dest; diff --git a/src/metatile_behavior.c b/src/metatile_behavior.c index c937a3b48..77c839b89 100644 --- a/src/metatile_behavior.c +++ b/src/metatile_behavior.c @@ -199,7 +199,7 @@ bool8 MetatileBehavior_IsNonAnimDoor(u8 metatileBehavior) return FALSE; } -bool8 MetatileBehavior_ReturnFalse_2(u8 metatileBehavior) { return FALSE; } +bool8 MetatileBehavior_IsDeepSouthWarp(u8 metatileBehavior) { return FALSE; } bool8 MetatileBehavior_IsSurfable(u8 metatileBehavior) { @@ -664,7 +664,7 @@ bool8 MetatileBehavior_IsFallWarp(u8 metatileBehavior) bool8 MetatileBehavior_ReturnFalse_13(u8 metatileBehavior){ return FALSE; } -bool8 MetatileBehavior_IsCyclingRoadPullDownTile(u8 metatileBehavior) +bool32 MetatileBehavior_IsCyclingRoadPullDownTile(u8 metatileBehavior) { if(metatileBehavior >= MB_CYCLING_ROAD_PULL_DOWN && metatileBehavior <= MB_CYCLING_ROAD_PULL_DOWN_GRASS) return TRUE; diff --git a/src/option_menu.c b/src/option_menu.c index 62e90c33b..87306c98f 100644 --- a/src/option_menu.c +++ b/src/option_menu.c @@ -509,7 +509,7 @@ static void BufferOptionMenuString(u8 selection) static void CloseAndSaveOptionMenu(u8 taskId) { - gFieldCallback = FieldCB_UnionRoomWarp; + gFieldCallback = FieldCB_DefaultWarpExit; SetMainCallback2(gMain.savedCallback); FreeAllWindowBuffers(); gSaveBlock2Ptr->optionsTextSpeed = sOptionMenuPtr->option[MENUITEM_TEXTSPEED]; diff --git a/src/overworld.c b/src/overworld.c new file mode 100644 index 000000000..e86939f10 --- /dev/null +++ b/src/overworld.c @@ -0,0 +1,3553 @@ +#include "global.h" +#include "gflib.h" +#include "bg_regs.h" +#include "cable_club.h" +#include "credits.h" +#include "event_data.h" +#include "event_object_movement.h" +#include "event_scripts.h" +#include "field_camera.h" +#include "field_control_avatar.h" +#include "field_effect.h" +#include "field_fadetransition.h" +#include "field_message_box.h" +#include "field_player_avatar.h" +#include "field_screen_effect.h" +#include "field_specials.h" +#include "field_tasks.h" +#include "field_weather.h" +#include "fieldmap.h" +#include "fldeff.h" +#include "heal_location.h" +#include "help_system.h" +#include "link.h" +#include "link_rfu.h" +#include "load_save.h" +#include "m4a.h" +#include "map_name_popup.h" +#include "map_preview_screen.h" +#include "metatile_behavior.h" +#include "money.h" +#include "new_game.h" +#include "new_menu_helpers.h" +#include "overworld.h" +#include "play_time.h" +#include "quest_log.h" +#include "quest_log_objects.h" +#include "random.h" +#include "renewable_hidden_items.h" +#include "roamer.h" +#include "safari_zone.h" +#include "save_location.h" +#include "scanline_effect.h" +#include "script.h" +#include "script_pokemon_util.h" +#include "start_menu.h" +#include "tileset_anims.h" +#include "trainer_pokemon_sprites.h" +#include "vs_seeker.h" +#include "wild_encounter.h" +#include "constants/maps.h" +#include "constants/flags.h" +#include "constants/species.h" +#include "constants/region_map_sections.h" +#include "constants/songs.h" + +#define PLAYER_TRADING_STATE_IDLE 0x80 +#define PLAYER_TRADING_STATE_BUSY 0x81 +#define PLAYER_TRADING_STATE_UNK_2 0x82 +#define PLAYER_TRADING_STATE_EXITING_ROOM 0x83 + +#define FACING_NONE 0 +#define FACING_UP 1 +#define FACING_DOWN 2 +#define FACING_LEFT 3 +#define FACING_RIGHT 4 +#define FACING_FORCED_UP 7 +#define FACING_FORCED_DOWN 8 +#define FACING_FORCED_LEFT 9 +#define FACING_FORCED_RIGHT 10 + +typedef u16 (*KeyInterCB)(u32 key); + +struct InitialPlayerAvatarState +{ + u8 transitionFlags; + u8 direction; + bool8 unk2; +}; + +struct TradeRoomPlayer +{ + u8 playerId; + bool8 isLocalPlayer; + u8 c; + u8 facing; + struct MapPosition pos; + u16 field_C; +}; + +EWRAM_DATA struct WarpData gLastUsedWarp = {}; +static EWRAM_DATA struct WarpData sWarpDestination = {}; +static EWRAM_DATA struct WarpData sFixedDiveWarp = {}; +static EWRAM_DATA struct WarpData sFixedHoleWarp = {}; + +// File boundary perhaps? +static EWRAM_DATA struct InitialPlayerAvatarState sInitialPlayerAvatarState = {}; + +// File boundary perhaps? +EWRAM_DATA bool8 gDisableMapMusicChangeOnMapLoad = FALSE; +static EWRAM_DATA u16 sAmbientCrySpecies = SPECIES_NONE; +static EWRAM_DATA bool8 sIsAmbientCryWaterMon = FALSE; + +// File boundary perhaps? +ALIGNED(4) EWRAM_DATA bool8 gUnknown_2031DE0 = FALSE; +static EWRAM_DATA const struct CreditsOverworldCmd *sCreditsOverworld_Script = NULL; +static EWRAM_DATA s16 sCreditsOverworld_CmdLength = 0; +static EWRAM_DATA s16 sCreditsOverworld_CmdIndex = 0; + +// File boundary perhaps? +EWRAM_DATA struct LinkPlayerObjectEvent gLinkPlayerObjectEvents[4] = {}; + +u16 *gBGTilemapBuffers1; +u16 *gBGTilemapBuffers2; +u16 *gBGTilemapBuffers3; +void (*gFieldCallback)(void); +bool8 (*gFieldCallback2)(void); +u16 gHeldKeyCodeToSend; +u8 gLocalLinkPlayerId; +u8 gFieldLinkPlayerCount; + +static u8 sPlayerTradingStates[4]; +static KeyInterCB sPlayerKeyInterceptCallback; +static bool8 gUnknown_3000E88; +static u8 sRfuKeepAliveTimer; + +static u8 CountBadgesForOverworldWhiteOutLossCalculation(void); +static void Overworld_ResetStateAfterWhitingOut(void); +static void Overworld_SetWhiteoutRespawnPoint(void); +static u8 GetAdjustedInitialTransitionFlags(struct InitialPlayerAvatarState *playerStruct, u16 metatileBehavior, u8 mapType); +static u8 GetAdjustedInitialDirection(struct InitialPlayerAvatarState *playerStruct, u8 transitionFlags, u16 metatileBehavior, u8 mapType); +static u16 GetCenterScreenMetatileBehavior(void); +static void SetDefaultFlashLevel(void); +static void Overworld_TryMapConnectionMusicTransition(void); +static void ChooseAmbientCrySpecies(void); + +static void CB2_Overworld(void); +static void CB2_LoadMap2(void); +static void c2_80567AC(void); +static void CB2_ReturnToFieldLocal(void); +static void CB2_ReturnToFieldLink(void); +static void FieldClearVBlankHBlankCallbacks(void); +static void SetFieldVBlankCallback(void); +static void VBlankCB_Field(void); + +static bool32 map_loading_iteration_3(u8 *state); +static bool32 sub_8056CD8(u8 *state); +static bool32 map_loading_iteration_2_link(u8 *state); +static void do_load_map_stuff_loop(u8 *state); +static void MoveSaveBlocks_ResetHeap_(void); +static void sub_8056E80(void); +static void sub_8056F08(void); +static void InitOverworldGraphicsRegisters(void); +static void sub_8057024(bool32 a0); +static void sub_8057074(void); +static void mli4_mapscripts_and_other(void); +static void sub_8057100(void); +static void sub_8057114(void); +static void SetCameraToTrackGuestPlayer(void); +static void SetCameraToTrackGuestPlayer_2(void); +static void sub_8057178(void); +static void sub_80571A8(void); +static void CreateLinkPlayerSprites(void); +static void sub_80572D8(void); +static void sub_8057300(u8 *state); +static bool32 sub_8057314(u8 *state); +static bool32 SetUpScrollSceneForCredits(u8 *state, u8 unused); +static bool8 MapLdr_Credits(void); +static void CameraCB_CreditsPan(struct CameraObject * camera); +static void Task_OvwldCredits_FadeOut(u8 taskId); +static void Task_OvwldCredits_WaitFade(u8 taskId); + +static void CB1_UpdateLinkState(void); +static void ResetAllMultiplayerState(void); +static void ClearAllPlayerKeys(void); +static void SetKeyInterceptCallback(KeyInterCB callback); +static void ResetAllTradingStates(void); +static void UpdateAllLinkPlayers(u16 *linkKeys, s32 selfId); +static void UpdateHeldKeyCode(u16 interceptedKeys); +static u32 GetLinkSendQueueLength(void); +static u16 GetDirectionForDpadKey(u16 key); +static void SetPlayerFacingDirection(u8 linkPlayerId, u8 setFacing); +static void ResetPlayerHeldKeys(u16 *linkKeys); +static u16 KeyInterCB_SelfIdle(u32 linkPlayerId); +static u16 KeyInterCB_DeferToEventScript(u32 linkPlayerId); +static u16 KeyInterCB_DeferToRecvQueue(u32 linkPlayerId); +static u16 KeyInterCB_DeferToSendQueue(u32 linkPlayerId); +static void LoadTradeRoomPlayer(s32 i, s32 selfId, struct TradeRoomPlayer * trainer); +static bool32 PlayerIsAtSouthExit(struct TradeRoomPlayer * player); +static const u8 *TryGetTileEventScript(struct TradeRoomPlayer * player); +static const u8 *TryInteractWithPlayer(struct TradeRoomPlayer * player); +static bool32 sub_8057FEC(struct TradeRoomPlayer * player); +static bool32 sub_8058004(struct TradeRoomPlayer * player); +static u16 GetDirectionForEventScript(const u8 *script); +static void sub_80581BC(void); +static void CreateConfirmLeaveTradeRoomPrompt(void); +static void InitLinkRoomStartMenuScript(void); +static void InitMenuBasedScript(const u8 *script); +static void sub_80581DC(const u8 *script); +static void sub_8058230(void); +static void SpawnLinkPlayerObjectEvent(u8 i, s16 x, s16 y, u8 gender); +static void InitLinkPlayerObjectEventPos(struct ObjectEvent *objEvent, s16 x, s16 y); +static u8 GetSpriteForLinkedPlayer(u8 linkPlayerId); +static void GetLinkPlayerCoords(u8 linkPlayerId, u16 *x, u16 *y); +static u8 GetLinkPlayerFacingDirection(u8 linkPlayerId); +static u8 GetLinkPlayerElevation(u8 linkPlayerId); +static u8 GetLinkPlayerIdAt(s16 x, s16 y); +static void CreateLinkPlayerSprite(u8 i, u8 version); +static u8 MovementEventModeCB_Normal(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 MovementEventModeCB_Ignored(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 MovementEventModeCB_Normal_2(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 FacingHandler_DoNothing(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 FacingHandler_DpadMovement(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static u8 FacingHandler_ForcedFacingChange(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8); +static void MovementStatusHandler_EnterFreeMode(struct LinkPlayerObjectEvent *, struct ObjectEvent *); +static void MovementStatusHandler_TryAdvanceScript(struct LinkPlayerObjectEvent *, struct ObjectEvent *); +static u8 FlipVerticalAndClearForced(u8 newFacing, u8 oldFacing); +static u8 LinkPlayerDetectCollision(u8 selfObjEventId, u8 a2, s16 x, s16 y); +static void SpriteCB_LinkPlayer(struct Sprite * sprite); + +extern const struct MapLayout * gMapLayouts[]; +extern const struct MapHeader *const *gMapGroups[]; + +// Routines related to game state on warping in + +static const u8 sWhiteOutMoneyLossMultipliers[] = { + 2, + 4, + 6, + 9, + 12, + 16, + 20, + 25, + 30 +}; + +static const u16 sWhiteOutMoneyLossBadgeFlagIDs[] = { + FLAG_BADGE01_GET, + FLAG_BADGE02_GET, + FLAG_BADGE03_GET, + FLAG_BADGE04_GET, + FLAG_BADGE05_GET, + FLAG_BADGE06_GET, + FLAG_BADGE07_GET, + FLAG_BADGE08_GET +}; + +static void DoWhiteOut(void) +{ + ScriptContext2_RunNewScript(EventScript_ResetEliteFourEnd); + RemoveMoney(&gSaveBlock1Ptr->money, ComputeWhiteOutMoneyLoss()); + HealPlayerParty(); + Overworld_ResetStateAfterWhitingOut(); + Overworld_SetWhiteoutRespawnPoint(); + WarpIntoMap(); +} + +u32 ComputeWhiteOutMoneyLoss(void) +{ + u8 nbadges = CountBadgesForOverworldWhiteOutLossCalculation(); + u8 toplevel = GetPlayerPartyHighestLevel(); + u32 losings = toplevel * 4 * sWhiteOutMoneyLossMultipliers[nbadges]; + u32 money = GetMoney(&gSaveBlock1Ptr->money); + if (losings > money) + losings = money; + return losings; +} + +void OverworldWhiteOutGetMoneyLoss(void) +{ + u32 losings = ComputeWhiteOutMoneyLoss(); + ConvertIntToDecimalStringN(gStringVar1, losings, STR_CONV_MODE_LEFT_ALIGN, CountDigits(losings)); +} + +static u8 CountBadgesForOverworldWhiteOutLossCalculation(void) +{ + int i; + u8 nbadges = 0; + for (i = 0; i < NELEMS(sWhiteOutMoneyLossBadgeFlagIDs); i++) + { + if (FlagGet(sWhiteOutMoneyLossBadgeFlagIDs[i])) + nbadges++; + } + return nbadges; +} + +void Overworld_ResetStateAfterFly(void) +{ + ResetInitialPlayerAvatarState(); + FlagClear(FLAG_SYS_ON_CYCLING_ROAD); + VarSet(VAR_MAP_SCENE_ROUTE16, 0); + FlagClear(FLAG_SYS_CRUISE_MODE); + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + FlagClear(FLAG_SYS_USE_STRENGTH); + FlagClear(FLAG_SYS_FLASH_ACTIVE); + FlagClear(FLAG_0x808); + VarSet(VAR_0x404D, 0); +} + +void Overworld_ResetStateAfterTeleport(void) +{ + ResetInitialPlayerAvatarState(); + FlagClear(FLAG_SYS_ON_CYCLING_ROAD); + VarSet(VAR_MAP_SCENE_ROUTE16, 0); + FlagClear(FLAG_SYS_CRUISE_MODE); + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + FlagClear(FLAG_SYS_USE_STRENGTH); + FlagClear(FLAG_SYS_FLASH_ACTIVE); + FlagClear(FLAG_0x808); + VarSet(VAR_0x404D, 0); +} + +void Overworld_ResetStateAfterDigEscRope(void) +{ + ResetInitialPlayerAvatarState(); + FlagClear(FLAG_SYS_ON_CYCLING_ROAD); + VarSet(VAR_MAP_SCENE_ROUTE16, 0); + FlagClear(FLAG_SYS_CRUISE_MODE); + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + FlagClear(FLAG_SYS_USE_STRENGTH); + FlagClear(FLAG_SYS_FLASH_ACTIVE); + FlagClear(FLAG_0x808); + VarSet(VAR_0x404D, 0); +} + +static void Overworld_ResetStateAfterWhitingOut(void) +{ + ResetInitialPlayerAvatarState(); + FlagClear(FLAG_SYS_ON_CYCLING_ROAD); + VarSet(VAR_MAP_SCENE_ROUTE16, 0); + FlagClear(FLAG_SYS_CRUISE_MODE); + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + FlagClear(FLAG_SYS_USE_STRENGTH); + FlagClear(FLAG_SYS_FLASH_ACTIVE); + FlagClear(FLAG_0x808); + VarSet(VAR_0x404D, 0); +} + +static void sub_8054E40(void) +{ + FlagClear(FLAG_SYS_SAFARI_MODE); + VarSet(VAR_MAP_SCENE_FUCHSIA_CITY_SAFARI_ZONE_ENTRANCE, 0); + ChooseAmbientCrySpecies(); + UpdateLocationHistoryForRoamer(); + RoamerMoveToOtherLocationSet(); +} + +// Routines related to game stats + +void ResetGameStats(void) +{ + int i; + + for (i = 0; i < NUM_GAME_STATS; i++) + { + gSaveBlock1Ptr->gameStats[i] = 0; + } +} + +void IncrementGameStat(u8 statId) +{ + u32 statVal; + if (statId >= NUM_USED_GAME_STATS) + return; + statVal = GetGameStat(statId); + if (statVal < 0xFFFFFF) + statVal++; + else + statVal = 0xFFFFFF; + SetGameStat(statId, statVal); +} + +u32 GetGameStat(u8 statId) +{ + if (statId >= NUM_USED_GAME_STATS) + return 0; + else + return gSaveBlock1Ptr->gameStats[statId] ^ gSaveBlock2Ptr->encryptionKey; +} + +void SetGameStat(u8 statId, u32 statVal) +{ + if (statId >= NUM_USED_GAME_STATS) + return; + gSaveBlock1Ptr->gameStats[statId] = statVal ^ gSaveBlock2Ptr->encryptionKey; +} + +void ApplyNewEncryptionKeyToGameStats(u32 newKey) +{ + u8 i; + for (i = 0; i < NUM_GAME_STATS; i++) + { + ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->gameStats[i], newKey); + } +} + +// Routines related to object events + +static void sub_8054F68(void) +{ + u8 i, j; + u8 mapGroup; + u8 mapNum; + u8 localId; + const struct MapHeader * linkedMap; + + for (i = 0, j = 0; i < gMapHeader.events->objectEventCount; i++) + { + if (gMapHeader.events->objectEvents[i].unk2 == 0xFF) + { + localId = gMapHeader.events->objectEvents[i].elevation; + mapNum = gMapHeader.events->objectEvents[i].trainerType; + mapGroup = gMapHeader.events->objectEvents[i].trainerRange_berryTreeId; + linkedMap = Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum); + gSaveBlock1Ptr->objectEventTemplates[j] = linkedMap->events->objectEvents[localId - 1]; + gSaveBlock1Ptr->objectEventTemplates[j].localId = gMapHeader.events->objectEvents[i].localId; + gSaveBlock1Ptr->objectEventTemplates[j].x = gMapHeader.events->objectEvents[i].x; + gSaveBlock1Ptr->objectEventTemplates[j].y = gMapHeader.events->objectEvents[i].y; + gSaveBlock1Ptr->objectEventTemplates[j].elevation = localId; + gSaveBlock1Ptr->objectEventTemplates[j].trainerType = mapNum; + gSaveBlock1Ptr->objectEventTemplates[j].trainerRange_berryTreeId = mapGroup; + gSaveBlock1Ptr->objectEventTemplates[j].unk2 = 0xFF; + j++; + } + else + { + gSaveBlock1Ptr->objectEventTemplates[j] = gMapHeader.events->objectEvents[i]; + j++; + } + } +} + +static void LoadSaveblockObjEventScripts(void) +{ + int i; + const struct ObjectEventTemplate * src = gMapHeader.events->objectEvents; + struct ObjectEventTemplate * savObjTemplates = gSaveBlock1Ptr->objectEventTemplates; + + for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++) + { + savObjTemplates[i].script = src[i].script; + } +} + +void Overworld_SetMapObjTemplateCoords(u8 localId, s16 x, s16 y) +{ + int i; + struct ObjectEventTemplate * savObjTemplates = gSaveBlock1Ptr->objectEventTemplates; + for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++) + { + if (savObjTemplates[i].localId == localId) + { + savObjTemplates[i].x = x; + savObjTemplates[i].y = y; + break; + } + } +} + +void Overworld_SetObjEventTemplateMovementType(u8 localId, u8 movementType) +{ + s32 i; + + struct ObjectEventTemplate *savObjTemplates = gSaveBlock1Ptr->objectEventTemplates; + for (i = 0; i < OBJECT_EVENT_TEMPLATES_COUNT; i++) + { + struct ObjectEventTemplate *objectEventTemplate = &savObjTemplates[i]; + if (objectEventTemplate->localId == localId) + { + objectEventTemplate->movementType = movementType; + return; + } + } +} + +// Routines related to the map layout + +static void mapdata_load_assets_to_gpu_and_full_redraw(void) +{ + move_tilemap_camera_to_upper_left_corner(); + copy_map_tileset1_tileset2_to_vram(gMapHeader.mapLayout); + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + DrawWholeMapView(); + InitTilesetAnimations(); +} + +static const struct MapLayout *GetMapLayout(void) +{ + u16 mapLayoutId = gSaveBlock1Ptr->mapLayoutId; + if (mapLayoutId) + return gMapLayouts[mapLayoutId - 1]; + return NULL; +} + +// Routines related to warps + +static const struct WarpData sDummyWarpData = { + .mapGroup = MAP_GROUP(UNDEFINED), + .mapNum = MAP_NUM(UNDEFINED), + .warpId = 0xFF, + .x = -1, + .y = -1 +}; + +static void ApplyCurrentWarp(void) +{ + gLastUsedWarp = gSaveBlock1Ptr->location; + gSaveBlock1Ptr->location = sWarpDestination; + sFixedDiveWarp = sDummyWarpData; + sFixedHoleWarp = sDummyWarpData; +} + +static void SetWarpData(struct WarpData *warp, s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + warp->mapGroup = mapGroup; + warp->mapNum = mapNum; + warp->warpId = warpId; + warp->x = x; + warp->y = y; +} + +static bool32 IsDummyWarp(struct WarpData *warp) +{ + if (warp->mapGroup != -1) + return FALSE; + else if (warp->mapNum != -1) + return FALSE; + else if (warp->warpId != -1) + return FALSE; + else if (warp->x != -1) + return FALSE; + else if (warp->y != -1) + return FALSE; + else + return TRUE; +} + +struct MapHeader const *const Overworld_GetMapHeaderByGroupAndId(u16 mapGroup, u16 mapNum) +{ + return gMapGroups[mapGroup][mapNum]; +} + +struct MapHeader const *const GetDestinationWarpMapHeader(void) +{ + return Overworld_GetMapHeaderByGroupAndId(sWarpDestination.mapGroup, sWarpDestination.mapNum); +} + +static void LoadCurrentMapData(void) +{ + gMapHeader = *Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); + gSaveBlock1Ptr->mapLayoutId = gMapHeader.mapLayoutId; + gMapHeader.mapLayout = GetMapLayout(); +} + +static void LoadSaveblockMapHeader(void) +{ + gMapHeader = *Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); + gMapHeader.mapLayout = GetMapLayout(); +} + +static void SetPlayerCoordsFromWarp(void) +{ + if (gSaveBlock1Ptr->location.warpId >= 0 && gSaveBlock1Ptr->location.warpId < gMapHeader.events->warpCount) + { + gSaveBlock1Ptr->pos.x = gMapHeader.events->warps[gSaveBlock1Ptr->location.warpId].x; + gSaveBlock1Ptr->pos.y = gMapHeader.events->warps[gSaveBlock1Ptr->location.warpId].y; + } + else if (gSaveBlock1Ptr->location.x >= 0 && gSaveBlock1Ptr->location.y >= 0) + { + gSaveBlock1Ptr->pos.x = gSaveBlock1Ptr->location.x; + gSaveBlock1Ptr->pos.y = gSaveBlock1Ptr->location.y; + } + else + { + gSaveBlock1Ptr->pos.x = gMapHeader.mapLayout->width / 2; + gSaveBlock1Ptr->pos.y = gMapHeader.mapLayout->height / 2; + } +} + +void WarpIntoMap(void) +{ + ApplyCurrentWarp(); + LoadCurrentMapData(); + SetPlayerCoordsFromWarp(); +} + +void SetWarpDestination(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&sWarpDestination, mapGroup, mapNum, warpId, x, y); +} + +void SetWarpDestinationToMapWarp(s8 mapGroup, s8 mapNum, s8 warpId) +{ + SetWarpDestination(mapGroup, mapNum, warpId, -1, -1); +} + +void SetDynamicWarp(s32 unused, s8 mapGroup, s8 mapNum, s8 warpId) +{ + SetWarpData(&gSaveBlock1Ptr->dynamicWarp, mapGroup, mapNum, warpId, gSaveBlock1Ptr->pos.x, gSaveBlock1Ptr->pos.y); +} + +void SetDynamicWarpWithCoords(s32 unused, s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&gSaveBlock1Ptr->dynamicWarp, mapGroup, mapNum, warpId, x, y); +} + +void SetWarpDestinationToDynamicWarp(u8 unusedWarpId) +{ + sWarpDestination = gSaveBlock1Ptr->dynamicWarp; +} + +void SetWarpDestinationToHealLocation(u8 healLocationId) +{ + const struct HealLocation *warp = GetHealLocation(healLocationId); + if (warp) + SetWarpDestination(warp->group, warp->map, -1, warp->x, warp->y); +} + +void SetWarpDestinationToLastHealLocation(void) +{ + sWarpDestination = gSaveBlock1Ptr->lastHealLocation; +} + +static void Overworld_SetWhiteoutRespawnPoint(void) +{ + SetWhiteoutRespawnWarpAndHealerNpc(&sWarpDestination); +} + +void SetLastHealLocationWarp(u8 healLocationId) +{ + const struct HealLocation *healLocation = GetHealLocation(healLocationId); + if (healLocation) + SetWarpData(&gSaveBlock1Ptr->lastHealLocation, healLocation->group, healLocation->map, -1, healLocation->x, healLocation->y); +} + +void UpdateEscapeWarp(s16 x, s16 y) +{ + u8 currMapType = GetCurrentMapType(); + u8 destMapType = GetMapTypeByGroupAndId(sWarpDestination.mapGroup, sWarpDestination.mapNum); + u8 delta; + if (IsMapTypeOutdoors(currMapType) && IsMapTypeOutdoors(destMapType) != TRUE && !(gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(VIRIDIAN_FOREST) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(VIRIDIAN_FOREST))) + { + delta = GetPlayerFacingDirection() != DIR_SOUTH; + SetEscapeWarp(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum, -1, x - 7, y - 7 + delta); + } +} + +void SetEscapeWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&gSaveBlock1Ptr->escapeWarp, mapGroup, mapNum, warpId, x, y); +} + +void SetWarpDestinationToEscapeWarp(void) +{ + sWarpDestination = gSaveBlock1Ptr->escapeWarp; +} + +void SetFixedDiveWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&sFixedDiveWarp, mapGroup, mapNum, warpId, x, y); +} + +static void SetWarpDestinationToDiveWarp(void) +{ + sWarpDestination = sFixedDiveWarp; +} + +void SetFixedHoleWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&sFixedHoleWarp, mapGroup, mapNum, warpId, x, y); +} + +void SetWarpDestinationToFixedHoleWarp(s16 x, s16 y) +{ + if (IsDummyWarp(&sFixedHoleWarp) == TRUE) + sWarpDestination = gLastUsedWarp; + else + SetWarpDestination(sFixedHoleWarp.mapGroup, sFixedHoleWarp.mapNum, -1, x, y); +} + +static void SetWarpDestinationToContinueGameWarp(void) +{ + sWarpDestination = gSaveBlock1Ptr->continueGameWarp; +} + +static void SetContinueGameWarp(s8 mapGroup, s8 mapNum, s8 warpId, s8 x, s8 y) +{ + SetWarpData(&gSaveBlock1Ptr->continueGameWarp, mapGroup, mapNum, warpId, x, y); +} + +void SetContinueGameWarpToHealLocation(u8 healLocationId) +{ + const struct HealLocation *warp = GetHealLocation(healLocationId); + if (warp) + SetWarpData(&gSaveBlock1Ptr->continueGameWarp, warp->group, warp->map, -1, warp->x, warp->y); +} + +void SetContinueGameWarpToDynamicWarp(int unused) +{ + gSaveBlock1Ptr->continueGameWarp = gSaveBlock1Ptr->dynamicWarp; +} + +static const struct MapConnection * GetMapConnection(u8 dir) +{ + s32 i; + s32 count = gMapHeader.connections->count; + const struct MapConnection *connection = gMapHeader.connections->connections; + + if (connection == NULL) + return NULL; + + for(i = 0; i < count; i++, connection++) + if (connection->direction == dir) + return connection; + + return NULL; +} + +static bool8 SetDiveWarp(u8 dir, u16 x, u16 y) +{ + const struct MapConnection *connection = GetMapConnection(dir); + + if (connection != NULL) + { + SetWarpDestination(connection->mapGroup, connection->mapNum, -1, x, y); + } + else + { + RunOnDiveWarpMapScript(); + if (IsDummyWarp(&sFixedDiveWarp)) + return FALSE; + SetWarpDestinationToDiveWarp(); + } + return TRUE; +} + +bool8 SetDiveWarpEmerge(u16 x, u16 y) +{ + return SetDiveWarp(CONNECTION_EMERGE, x, y); +} + +bool8 SetDiveWarpDive(u16 x, u16 y) +{ + return SetDiveWarp(CONNECTION_DIVE, x, y); +} + +// Map loaders + +void LoadMapFromCameraTransition(u8 mapGroup, u8 mapNum) +{ + int paletteIndex; + + SetWarpDestination(mapGroup, mapNum, -1, -1, -1); + Overworld_TryMapConnectionMusicTransition(); + ApplyCurrentWarp(); + LoadCurrentMapData(); + sub_8054F68(); + TrySetMapSaveWarpStatus(); + ClearTempFieldEventData(); + ResetCyclingRoadChallengeData(); + RestartWildEncounterImmunitySteps(); + TryUpdateRandomTrainerRematches(mapGroup, mapNum); + SetSav1WeatherFromCurrMapHeader(); + ChooseAmbientCrySpecies(); + SetDefaultFlashLevel(); + Overworld_ClearSavedMusic(); + RunOnTransitionMapScript(); + TryRegenerateRenewableHiddenItems(); + InitMap(); + copy_map_tileset2_to_vram_2(gMapHeader.mapLayout); + apply_map_tileset2_palette(gMapHeader.mapLayout); + for (paletteIndex = 7; paletteIndex < 13; paletteIndex++) + ApplyWeatherGammaShiftToPal(paletteIndex); + InitSecondaryTilesetAnimation(); + UpdateLocationHistoryForRoamer(); + RoamerMove(); + sub_8110920(); + DoCurrentWeather(); + ResetFieldTasksArgs(); + RunOnResumeMapScript(); + if (GetLastUsedWarpMapSectionId() != gMapHeader.regionMapSectionId) + ShowMapNamePopup(TRUE); +} + +static void mli0_load_map(bool32 a1) +{ + bool8 isOutdoors; + + LoadCurrentMapData(); + sub_8054F68(); + isOutdoors = IsMapTypeOutdoors(gMapHeader.mapType); + + TrySetMapSaveWarpStatus(); + ClearTempFieldEventData(); + ResetCyclingRoadChallengeData(); + RestartWildEncounterImmunitySteps(); + TryUpdateRandomTrainerRematches(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum); + SetSav1WeatherFromCurrMapHeader(); + ChooseAmbientCrySpecies(); + if (isOutdoors) + FlagClear(FLAG_SYS_FLASH_ACTIVE); + SetDefaultFlashLevel(); + Overworld_ClearSavedMusic(); + RunOnTransitionMapScript(); + TryRegenerateRenewableHiddenItems(); + UpdateLocationHistoryForRoamer(); + RoamerMoveToOtherLocationSet(); + sub_8110920(); + InitMap(); +} + +static void sub_80559A8(void) +{ + bool8 isOutdoors; + + LoadCurrentMapData(); + sub_8054F68(); + isOutdoors = IsMapTypeOutdoors(gMapHeader.mapType); + TrySetMapSaveWarpStatus(); + SetSav1WeatherFromCurrMapHeader(); + ChooseAmbientCrySpecies(); + SetDefaultFlashLevel(); + sub_8110920(); + sub_8111708(); + LoadSaveblockMapHeader(); + InitMap(); +} + +// Routines related to the initial player avatar state + +void ResetInitialPlayerAvatarState(void) +{ + sInitialPlayerAvatarState.direction = DIR_SOUTH; + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT; + sInitialPlayerAvatarState.unk2 = FALSE; +} + +static void SetInitialPlayerAvatarStateWithDirection(u8 dirn) +{ + sInitialPlayerAvatarState.direction = dirn; + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT; + sInitialPlayerAvatarState.unk2 = TRUE; +} + +void StoreInitialPlayerAvatarState(void) +{ + sInitialPlayerAvatarState.direction = GetPlayerFacingDirection(); + + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE)) + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_MACH_BIKE; + else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_ACRO_BIKE)) + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ACRO_BIKE; + else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING)) + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_SURFING; + else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_UNDERWATER)) + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_UNDERWATER; + else + sInitialPlayerAvatarState.transitionFlags = PLAYER_AVATAR_FLAG_ON_FOOT; + sInitialPlayerAvatarState.unk2 = FALSE; +} + +struct InitialPlayerAvatarState *GetInitialPlayerAvatarState(void) +{ + struct InitialPlayerAvatarState playerStruct; + u8 mapType = GetCurrentMapType(); + u16 metatileBehavior = GetCenterScreenMetatileBehavior(); + u8 transitionFlags = GetAdjustedInitialTransitionFlags(&sInitialPlayerAvatarState, metatileBehavior, mapType); + playerStruct.transitionFlags = transitionFlags; + playerStruct.direction = GetAdjustedInitialDirection(&sInitialPlayerAvatarState, transitionFlags, metatileBehavior, mapType); + playerStruct.unk2 = FALSE; + sInitialPlayerAvatarState = playerStruct; + return &sInitialPlayerAvatarState; +} + +static u8 GetAdjustedInitialTransitionFlags(struct InitialPlayerAvatarState *playerStruct, u16 metatileBehavior, u8 mapType) +{ + if (mapType != MAP_TYPE_INDOOR && FlagGet(FLAG_SYS_CRUISE_MODE)) + return PLAYER_AVATAR_FLAG_ON_FOOT; + else if (mapType == MAP_TYPE_UNDERWATER) + return PLAYER_AVATAR_FLAG_UNDERWATER; + else if (sub_8055B38(metatileBehavior) == TRUE) + return PLAYER_AVATAR_FLAG_ON_FOOT; + else if (MetatileBehavior_IsSurfable(metatileBehavior) == TRUE) + return PLAYER_AVATAR_FLAG_SURFING; + else if (Overworld_IsBikingAllowed() != TRUE) + return PLAYER_AVATAR_FLAG_ON_FOOT; + else if (playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_MACH_BIKE) + return PLAYER_AVATAR_FLAG_MACH_BIKE; + else if (playerStruct->transitionFlags != PLAYER_AVATAR_FLAG_ACRO_BIKE) + return PLAYER_AVATAR_FLAG_ON_FOOT; + else + return PLAYER_AVATAR_FLAG_ACRO_BIKE; +} + +bool8 sub_8055B38(u16 metatileBehavior) +{ + if (MetatileBehavior_IsSurfable(metatileBehavior) != TRUE) + return FALSE; + if ((gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEAFOAM_ISLANDS_B3F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEAFOAM_ISLANDS_B3F)) || (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(SEAFOAM_ISLANDS_B4F) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(SEAFOAM_ISLANDS_B4F))) + return TRUE; + return FALSE; +} + +static u8 GetAdjustedInitialDirection(struct InitialPlayerAvatarState *playerStruct, u8 transitionFlags, u16 metatileBehavior, u8 mapType) +{ + if (FlagGet(FLAG_SYS_CRUISE_MODE) && mapType == MAP_TYPE_OCEAN_ROUTE) + return DIR_EAST; + else if (MetatileBehavior_IsDeepSouthWarp(metatileBehavior) == TRUE) + return DIR_NORTH; + else if (MetatileBehavior_IsNonAnimDoor(metatileBehavior) == TRUE || MetatileBehavior_IsWarpDoor_2(metatileBehavior) == TRUE) + return DIR_SOUTH; + else if (MetatileBehavior_IsSouthArrowWarp(metatileBehavior) == TRUE) + return DIR_NORTH; + else if (MetatileBehavior_IsNorthArrowWarp(metatileBehavior) == TRUE) + return DIR_SOUTH; + else if (MetatileBehavior_IsWestArrowWarp(metatileBehavior) == TRUE) + return DIR_EAST; + else if (MetatileBehavior_IsEastArrowWarp(metatileBehavior) == TRUE) + return DIR_WEST; + else if (MetatileBehavior_IsUnknownWarp6C(metatileBehavior) == TRUE || MetatileBehavior_IsUnknownWarp6E(metatileBehavior) == TRUE) + return DIR_WEST; + else if (MetatileBehavior_IsUnknownWarp6D(metatileBehavior) == TRUE || MetatileBehavior_IsUnknownWarp6F(metatileBehavior) == TRUE) + return DIR_EAST; + else if ((playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_UNDERWATER && transitionFlags == PLAYER_AVATAR_FLAG_SURFING) + || (playerStruct->transitionFlags == PLAYER_AVATAR_FLAG_SURFING && transitionFlags == PLAYER_AVATAR_FLAG_UNDERWATER )) + return playerStruct->direction; + else if (MetatileBehavior_IsLadder(metatileBehavior) == TRUE) + return playerStruct->direction; + else if (playerStruct->unk2) + return playerStruct->direction; + else + return DIR_SOUTH; +} + +static u16 GetCenterScreenMetatileBehavior(void) +{ + return MapGridGetMetatileBehaviorAt(gSaveBlock1Ptr->pos.x + 7, gSaveBlock1Ptr->pos.y + 7); +} + +// Routines related to flash level and map perms + +bool32 Overworld_IsBikingAllowed(void) +{ + if (!gMapHeader.bikingAllowed) + return FALSE; + else + return TRUE; +} + +static void SetDefaultFlashLevel(void) +{ + if (!gMapHeader.cave) + gSaveBlock1Ptr->flashLevel = 0; + else if (FlagGet(FLAG_SYS_FLASH_ACTIVE)) + gSaveBlock1Ptr->flashLevel = 0; + else + gSaveBlock1Ptr->flashLevel = gMaxFlashLevel; +} + +void Overworld_SetFlashLevel(s32 flashLevel) +{ + if (flashLevel < 0 || flashLevel > gMaxFlashLevel) + flashLevel = 0; + gSaveBlock1Ptr->flashLevel = flashLevel; +} + +u8 Overworld_GetFlashLevel(void) +{ + return gSaveBlock1Ptr->flashLevel; +} + +void SetCurrentMapLayout(u16 mapLayoutId) +{ + gSaveBlock1Ptr->mapLayoutId = mapLayoutId; + gMapHeader.mapLayout = GetMapLayout(); +} + +void sub_8055D5C(struct WarpData * warp) +{ + sWarpDestination = *warp; +} + +// Routines related to map music + +static u16 GetLocationMusic(struct WarpData * warp) +{ + return Overworld_GetMapHeaderByGroupAndId(warp->mapGroup, warp->mapNum)->music; +} + +static u16 GetCurrLocationDefaultMusic(void) +{ + u16 music; + music = GetLocationMusic(&gSaveBlock1Ptr->location); + return music; +} + +static u16 GetWarpDestinationMusic(void) +{ + u16 music = GetLocationMusic(&sWarpDestination); + return music; +} + +void Overworld_ResetMapMusic(void) +{ + ResetMapMusic(); +} + +void Overworld_PlaySpecialMapMusic(void) +{ + u16 music; + s16 x, y; + + if (gDisableMapMusicChangeOnMapLoad == 1) + { + StopMapMusic(); + return; + } + if (gDisableMapMusicChangeOnMapLoad == 2) + { + return; + } + if (gSaveBlock1Ptr->location.mapGroup == MAP_GROUP(POKEMON_LEAGUE_CHAMPIONS_ROOM) && gSaveBlock1Ptr->location.mapNum == MAP_NUM(POKEMON_LEAGUE_CHAMPIONS_ROOM)) + { + PlayerGetDestCoords(&x, &y); + if (y - 7 < 11 && gMPlayInfo_BGM.songHeader == &mus_win_gym) + { + FadeInBGM(4); + return; + } + } + + music = GetCurrLocationDefaultMusic(); + + if (gSaveBlock1Ptr->savedMusic) + music = gSaveBlock1Ptr->savedMusic; + else if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) &&sub_8056124(MUS_NAMINORI)) + music = MUS_NAMINORI; + + if (music != GetCurrentMapMusic()) + PlayNewMapMusic(music); +} + +void Overworld_SetSavedMusic(u16 songNum) +{ + gSaveBlock1Ptr->savedMusic = songNum; +} + +void Overworld_ClearSavedMusic(void) +{ + gSaveBlock1Ptr->savedMusic = 0; +} + +static void Overworld_TryMapConnectionMusicTransition(void) +{ + u16 newMusic; + u16 currentMusic; + + if (gDisableMapMusicChangeOnMapLoad == 1) + { + StopMapMusic(); + return; + } + if (gDisableMapMusicChangeOnMapLoad == 2) + { + return; + } + + if (FlagGet(FLAG_DONT_TRANSITION_MUSIC) != TRUE) + { + newMusic = GetWarpDestinationMusic(); + currentMusic = GetCurrentMapMusic(); + if (currentMusic == MUS_NAMINORI) + return; + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_SURFING) && sub_8056124(MUS_NAMINORI)) + newMusic = MUS_NAMINORI; + if (newMusic != currentMusic) + { + if (TestPlayerAvatarFlags(PLAYER_AVATAR_FLAG_MACH_BIKE | PLAYER_AVATAR_FLAG_ACRO_BIKE)) + FadeOutAndFadeInNewMapMusic(newMusic, 4, 4); + else + FadeOutAndPlayNewMapMusic(newMusic, 8); + } + } +} + +void Overworld_ChangeMusicToDefault(void) +{ + u16 currentMusic = GetCurrentMapMusic(); + if (currentMusic != GetCurrLocationDefaultMusic()) + FadeOutAndPlayNewMapMusic(GetCurrLocationDefaultMusic(), 8); +} + +void Overworld_ChangeMusicTo(u16 newMusic) +{ + u16 currentMusic = GetCurrentMapMusic(); + if (currentMusic != newMusic) + FadeOutAndPlayNewMapMusic(newMusic, 8); +} + +static u8 GetMapMusicFadeoutSpeed(void) +{ + const struct MapHeader *mapHeader = GetDestinationWarpMapHeader(); + if (IsMapTypeIndoors(mapHeader->mapType) == TRUE) + return 2; + else + return 4; +} + +void TryFadeOutOldMapMusic(void) +{ + u16 warpMusic = GetWarpDestinationMusic(); + if (FlagGet(FLAG_DONT_TRANSITION_MUSIC) != TRUE && warpMusic != GetCurrentMapMusic()) + { + FadeOutMapMusic(GetMapMusicFadeoutSpeed()); + } +} + +bool8 BGMusicStopped(void) +{ + return IsNotWaitingForBGMStop(); +} + +void Overworld_FadeOutMapMusic(void) +{ + FadeOutMapMusic(4); +} + +static void PlayAmbientCry(void) +{ + s16 x, y; + s8 pan; + s8 volume; + + PlayerGetDestCoords(&x, &y); + if (sIsAmbientCryWaterMon == TRUE + && !MetatileBehavior_IsSurfable(MapGridGetMetatileBehaviorAt(x, y))) + return; + pan = (Random() % 88) + 212; + volume = (Random() % 30) + 50; + + if (gDisableMapMusicChangeOnMapLoad == 1) + { + StopMapMusic(); + return; + } + if (gDisableMapMusicChangeOnMapLoad == 2) + { + return; + } + + PlayCry2(sAmbientCrySpecies, pan, volume, 1); +} + +void UpdateAmbientCry(s16 *state, u16 *delayCounter) +{ + u8 i, monsCount, divBy; + + switch (*state) + { + case 0: + if (sAmbientCrySpecies == SPECIES_NONE) + *state = 4; + else + *state = 1; + break; + case 1: + *delayCounter = (Random() % 2400) + 1200; + *state = 3; + break; + case 2: + *delayCounter = (Random() % 1200) + 1200; + *state = 3; + break; + case 3: + (*delayCounter)--; + if (*delayCounter == 0) + { + PlayAmbientCry(); + *state = 2; + } + break; + case 4: + break; + } +} + +static void ChooseAmbientCrySpecies(void) +{ + sAmbientCrySpecies = GetLocalWildMon(&sIsAmbientCryWaterMon); +} + +bool32 sub_8056124(u16 music) +{ + if (music == MUS_CYCLING || music == MUS_NAMINORI) + { + if (gMapHeader.regionMapSectionId == MAPSEC_KANTO_VICTORY_ROAD || gMapHeader.regionMapSectionId == MAPSEC_ROUTE_23 || gMapHeader.regionMapSectionId == MAPSEC_INDIGO_PLATEAU) + return FALSE; + } + return TRUE; +} + +u8 GetMapTypeByGroupAndId(s8 mapGroup, s8 mapNum) +{ + return Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum)->mapType; +} + +static u8 GetMapTypeByWarpData(struct WarpData *warp) +{ + return GetMapTypeByGroupAndId(warp->mapGroup, warp->mapNum); +} + +u8 GetCurrentMapType(void) +{ + return GetMapTypeByWarpData(&gSaveBlock1Ptr->location); +} + +u8 GetLastUsedWarpMapType(void) +{ + return GetMapTypeByWarpData(&gLastUsedWarp); +} + +u8 GetLastUsedWarpMapSectionId(void) +{ + return Overworld_GetMapHeaderByGroupAndId(gLastUsedWarp.mapGroup, gLastUsedWarp.mapNum)->regionMapSectionId; +} + +bool8 IsMapTypeOutdoors(u8 mapType) +{ + if (mapType == MAP_TYPE_ROUTE + || mapType == MAP_TYPE_TOWN + || mapType == MAP_TYPE_UNDERWATER + || mapType == MAP_TYPE_CITY + || mapType == MAP_TYPE_OCEAN_ROUTE) + return TRUE; + else + return FALSE; +} + +bool8 Overworld_MapTypeAllowsTeleportAndFly(u8 mapType) +{ + if (mapType == MAP_TYPE_ROUTE + || mapType == MAP_TYPE_TOWN + || mapType == MAP_TYPE_OCEAN_ROUTE + || mapType == MAP_TYPE_CITY) + return TRUE; + else + return FALSE; +} + +bool8 IsMapTypeIndoors(u8 mapType) +{ + if (mapType == MAP_TYPE_INDOOR + || mapType == MAP_TYPE_SECRET_BASE) + return TRUE; + else + return FALSE; +} + +static u8 GetSavedWarpRegionMapSectionId(void) +{ + return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->dynamicWarp.mapGroup, gSaveBlock1Ptr->dynamicWarp.mapNum)->regionMapSectionId; +} + +u8 GetCurrentRegionMapSectionId(void) +{ + return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)->regionMapSectionId; +} + +u8 GetCurrentMapBattleScene(void) +{ + return Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)->battleType; +} + +static const int sUnusedData[] = { + 1200, + 3600, + 1200, + 2400, + 50, + 80, + -44, + 44 +}; + +const struct UCoords32 gDirectionToVectors[] = { + { 0u, 0u}, + { 0u, 1u}, + { 0u, -1u}, + {-1u, 0u}, + { 1u, 0u}, + {-1u, 1u}, + { 1u, 1u}, + {-1u, -1u}, + { 1u, -1u}, +}; + +static const struct BgTemplate sOverworldBgTemplates[] = { + { + .bg = 0, + .charBaseIndex = 2, + .mapBaseIndex = 31, + .screenSize = 0, + .paletteMode = 0, + .priority = 0, + .baseTile = 0x000 + }, { + .bg = 1, + .charBaseIndex = 0, + .mapBaseIndex = 29, + .screenSize = 0, + .paletteMode = 0, + .priority = 1, + .baseTile = 0x000 + }, { + .bg = 2, + .charBaseIndex = 0, + .mapBaseIndex = 28, + .screenSize = 0, + .paletteMode = 0, + .priority = 2, + .baseTile = 0x000 + }, { + .bg = 3, + .charBaseIndex = 0, + .mapBaseIndex = 30, + .screenSize = 0, + .paletteMode = 0, + .priority = 3, + .baseTile = 0x000 + } +}; + +static void InitOverworldBgs(void) +{ + MoveSaveBlocks_ResetHeap_(); + sub_8056E80(); + ResetBgsAndClearDma3BusyFlags(FALSE); + InitBgsFromTemplates(0, sOverworldBgTemplates, NELEMS(sOverworldBgTemplates)); + SetBgAttribute(1, BG_ATTR_MOSAIC, TRUE); + SetBgAttribute(2, BG_ATTR_MOSAIC, TRUE); + SetBgAttribute(3, BG_ATTR_MOSAIC, TRUE); + gBGTilemapBuffers2 = AllocZeroed(BG_SCREEN_SIZE); + gBGTilemapBuffers1 = AllocZeroed(BG_SCREEN_SIZE); + gBGTilemapBuffers3 = AllocZeroed(BG_SCREEN_SIZE); + SetBgTilemapBuffer(1, gBGTilemapBuffers2); + SetBgTilemapBuffer(2, gBGTilemapBuffers1); + SetBgTilemapBuffer(3, gBGTilemapBuffers3); + InitStandardTextBoxWindows(); + ResetBg0(); + sub_8069348(); +} + +static void InitOverworldBgs_NoResetHeap(void) +{ + ResetBgsAndClearDma3BusyFlags(FALSE); + InitBgsFromTemplates(0, sOverworldBgTemplates, NELEMS(sOverworldBgTemplates)); + SetBgAttribute(1, BG_ATTR_MOSAIC, TRUE); + SetBgAttribute(2, BG_ATTR_MOSAIC, TRUE); + SetBgAttribute(3, BG_ATTR_MOSAIC, TRUE); + gBGTilemapBuffers2 = AllocZeroed(BG_SCREEN_SIZE); + gBGTilemapBuffers1 = AllocZeroed(BG_SCREEN_SIZE); + gBGTilemapBuffers3 = AllocZeroed(BG_SCREEN_SIZE); + SetBgTilemapBuffer(1, gBGTilemapBuffers2); + SetBgTilemapBuffer(2, gBGTilemapBuffers1); + SetBgTilemapBuffer(3, gBGTilemapBuffers3); + InitStandardTextBoxWindows(); + ResetBg0(); + sub_8069348(); +} + +void CleanupOverworldWindowsAndTilemaps(void) +{ + FreeAllOverworldWindowBuffers(); + Free(gBGTilemapBuffers3); + Free(gBGTilemapBuffers1); + Free(gBGTilemapBuffers2); +} + +static void ResetSafariZoneFlag_(void) +{ + ResetSafariZoneFlag(); +} + +bool32 IsUpdateLinkStateCBActive(void) +{ + if (gMain.callback1 == CB1_UpdateLinkState) + return TRUE; + else + return FALSE; +} + +static void DoCB1_Overworld(u16 newKeys, u16 heldKeys) +{ + struct FieldInput fieldInput; + + sub_8112B3C(); + sub_805BEB8(); + FieldClearPlayerInput(&fieldInput); + FieldGetPlayerInput(&fieldInput, newKeys, heldKeys); + FieldInput_HandleCancelSignpost(&fieldInput); + if (!ScriptContext2_IsEnabled()) + { + if (ProcessPlayerFieldInput(&fieldInput) == TRUE) + { + if (gUnknown_3005E88 == 2) + sub_81127F8(&gInputToStoreInQuestLogMaybe); + ScriptContext2_Enable(); + DismissMapNamePopup(); + } + else + { + player_step(fieldInput.dpadDirection, newKeys, heldKeys); + } + } + RunQuestLogCB(); +} + +static void DoCB1_Overworld_QuestLogPlayback(void) +{ + struct FieldInput fieldInput; + + sub_8112B3C(); + sub_805BEB8(); + sub_8111C68(); + FieldClearPlayerInput(&fieldInput); + fieldInput = gUnknown_3005E90; + FieldInput_HandleCancelSignpost(&fieldInput); + if (!ScriptContext2_IsEnabled()) + { + if (ProcessPlayerFieldInput(&fieldInput) == TRUE) + { + ScriptContext2_Enable(); + DismissMapNamePopup(); + } + else + { + RunQuestLogCB(); + } + } + else if (sub_8111CD0() == TRUE) + { + RunQuestLogCB(); + } + FieldClearPlayerInput(&gUnknown_3005E90); +} + +void CB1_Overworld(void) +{ + if (gMain.callback2 == CB2_Overworld) + { + if (sub_8112CAC() == TRUE || gQuestLogState == QL_STATE_2) + DoCB1_Overworld_QuestLogPlayback(); + else + DoCB1_Overworld(gMain.newKeys, gMain.heldKeys); + } +} + +static void OverworldBasic(void) +{ + ScriptContext2_RunScript(); + RunTasks(); + AnimateSprites(); + CameraUpdate(); + sub_8115798(); + UpdateCameraPanning(); + BuildOamBuffer(); + UpdatePaletteFade(); + UpdateTilesetAnimations(); + DoScheduledBgTilemapCopiesToVram(); +} + +// This CB2 is used when starting +void CB2_OverworldBasic(void) +{ + OverworldBasic(); +} + +static void CB2_Overworld(void) +{ + bool32 fading = !!gPaletteFade.active; + if (fading) + SetVBlankCallback(NULL); + OverworldBasic(); + if (fading) + SetFieldVBlankCallback(); +} + +void SetMainCallback1(MainCallback cb) +{ + gMain.callback1 = cb; +} + +static bool8 map_post_load_hook_exec(void) +{ + if (gFieldCallback2) + { + if (!gFieldCallback2()) + { + return FALSE; + } + else + { + gFieldCallback2 = NULL; + gFieldCallback = NULL; + } + } + else + { + if (gFieldCallback) + gFieldCallback(); + else + FieldCB_DefaultWarpExit(); + + gFieldCallback = NULL; + } + + return TRUE; +} + +void CB2_NewGame(void) +{ + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + ResetSafariZoneFlag_(); + NewGameInitData(); + ResetInitialPlayerAvatarState(); + PlayTimeCounter_Start(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + gFieldCallback = FieldCB_WarpExitFadeFromBlack; + gFieldCallback2 = NULL; + do_load_map_stuff_loop(&gMain.state); + SetFieldVBlankCallback(); + SetMainCallback1(CB1_Overworld); + SetMainCallback2(CB2_Overworld); +} + +void CB2_WhiteOut(void) +{ + u8 val; + + if (++gMain.state >= 120) + { + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + ResetSafariZoneFlag_(); + DoWhiteOut(); + SetInitialPlayerAvatarStateWithDirection(DIR_NORTH); + ScriptContext1_Init(); + ScriptContext2_Disable(); + gFieldCallback = FieldCB_RushInjuredPokemonToCenter; + val = 0; + do_load_map_stuff_loop(&val); + sub_8112364(); + SetFieldVBlankCallback(); + SetMainCallback1(CB1_Overworld); + SetMainCallback2(CB2_Overworld); + } +} + +void CB2_LoadMap(void) +{ + FieldClearVBlankHBlankCallbacks(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + SetMainCallback1(NULL); + SetMainCallback2(CB2_DoChangeMap); + gMain.savedCallback = CB2_LoadMap2; +} + +static void CB2_LoadMap2(void) +{ + do_load_map_stuff_loop(&gMain.state); + if (sub_8113748() == TRUE) + { + sub_81119C8(); + } + else + { + SetFieldVBlankCallback(); + SetMainCallback1(CB1_Overworld); + SetMainCallback2(CB2_Overworld); + } +} + +void CB2_ReturnToFieldCableClub(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback = FieldCB_ReturnToFieldWirelessLink; + SetMainCallback2(c2_80567AC); +} + +static void c2_80567AC(void) +{ + if (map_loading_iteration_3(&gMain.state)) + { + SetFieldVBlankCallback(); + SetMainCallback1(CB1_UpdateLinkState); + ResetAllMultiplayerState(); + SetMainCallback2(CB2_Overworld); + } +} + +void CB2_ReturnToField(void) +{ + if (IsUpdateLinkStateCBActive() == TRUE) + { + SetMainCallback2(CB2_ReturnToFieldLink); + } + else + { + FieldClearVBlankHBlankCallbacks(); + SetMainCallback2(CB2_ReturnToFieldLocal); + } +} + +static void CB2_ReturnToFieldLocal(void) +{ + if (sub_8056CD8(&gMain.state)) + { + SetFieldVBlankCallback(); + SetMainCallback2(CB2_Overworld); + } +} + +static void CB2_ReturnToFieldLink(void) +{ + if (!sub_8058244() && map_loading_iteration_2_link(&gMain.state)) + SetMainCallback2(CB2_Overworld); +} + +void CB2_ReturnToFieldFromMultiplayer(void) +{ + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + SetMainCallback1(CB1_UpdateLinkState); + ResetAllMultiplayerState(); + + if (gWirelessCommType != 0) + gFieldCallback = FieldCB_ReturnToFieldWirelessLink; + else + gFieldCallback = FieldCB_ReturnToFieldCableLink; + + ScriptContext1_Init(); + ScriptContext2_Disable(); + CB2_ReturnToField(); +} + +void CB2_ReturnToFieldWithOpenMenu(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback2 = FieldCB_ReturnToFieldOpenStartMenu; + CB2_ReturnToField(); +} + +void CB2_ReturnToFieldContinueScript(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback = FieldCB_ContinueScript; + CB2_ReturnToField(); +} + +void CB2_ReturnToFieldContinueScriptPlayMapMusic(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback = FieldCB_ContinueScriptHandleMusic; + CB2_ReturnToField(); +} + +void sub_80568FC(void) +{ + FieldClearVBlankHBlankCallbacks(); + gFieldCallback = FieldCB_WarpExitFadeFromBlack; + CB2_ReturnToField(); +} + +static void sub_8056918(void) +{ + if (SHOW_MAP_NAME_ENABLED) + ShowMapNamePopup(FALSE); + FieldCB_WarpExitFadeFromBlack(); +} + +void CB2_ContinueSavedGame(void) +{ + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + ResetSafariZoneFlag_(); + LoadSaveblockMapHeader(); + LoadSaveblockObjEventScripts(); + UnfreezeObjectEvents(); + sub_8054E40(); + InitMapFromSavedGame(); + PlayTimeCounter_Start(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + gFieldCallback2 = NULL; + gUnknown_2031DE0 = TRUE; + if (UseContinueGameWarp() == TRUE) + { + ClearContinueGameWarpStatus(); + SetWarpDestinationToContinueGameWarp(); + WarpIntoMap(); + SetMainCallback2(CB2_LoadMap); + } + else + { + gFieldCallback = sub_8056918; + SetMainCallback1(CB1_Overworld); + CB2_ReturnToField(); + } +} + +static void FieldClearVBlankHBlankCallbacks(void) +{ + if (UsedPokemonCenterWarp() == TRUE) + CloseLink(); + + if (gWirelessCommType != 0) + { + EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_VCOUNT | INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL); + DisableInterrupts(INTR_FLAG_HBLANK); + } + else + { + DisableInterrupts(INTR_FLAG_HBLANK); + EnableInterrupts(INTR_FLAG_VBLANK); + } + + SetVBlankCallback(NULL); + SetHBlankCallback(NULL); +} + +static void SetFieldVBlankCallback(void) +{ + SetVBlankCallback(VBlankCB_Field); +} + +static void VBlankCB_Field(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + ScanlineEffect_InitHBlankDmaTransfer(); + FieldUpdateBgTilemapScroll(); + TransferPlttBuffer(); + TransferTilesetAnimsBuffer(); +} + +static void InitCurrentFlashLevelScanlineEffect(void) +{ + u8 flashLevel = Overworld_GetFlashLevel(); + if (flashLevel != 0) + { + WriteFlashScanlineEffectBuffer(flashLevel); + ScanlineEffect_SetParams((struct ScanlineEffectParams){ + .dmaDest = ®_WIN0H, + .dmaControl = (2 >> 1) | ((DMA_16BIT | DMA_DEST_RELOAD | DMA_SRC_INC | DMA_REPEAT | DMA_START_HBLANK | DMA_ENABLE) << 16), + .initState = 1, + .unused9 = 0 + }); + } +} + +static bool32 map_loading_iteration_3(u8 *state) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + (*state)++; + break; + case 1: + mli0_load_map(TRUE); + (*state)++; + break; + case 2: + sub_8057024(TRUE); + (*state)++; + break; + case 3: + sub_8057178(); + sub_8057074(); + sub_80571A8(); + SetCameraToTrackGuestPlayer(); + SetHelpContextForMap(); + (*state)++; + break; + case 4: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 5: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 6: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 7: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 8: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 9: + DrawWholeMapView(); + (*state)++; + break; + case 10: + InitTilesetAnimations(); + (*state)++; + break; + case 11: + if (gWirelessCommType != 0) + { + LoadWirelessStatusIndicatorSpriteGfx(); + CreateWirelessStatusIndicatorSprite(0, 0); + } + (*state)++; + break; + case 12: + if (map_post_load_hook_exec()) + (*state)++; + break; + case 13: + return TRUE; + } + + return FALSE; +} + +static bool32 load_map_stuff(u8 *state, bool32 a1) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + FieldClearVBlankHBlankCallbacks(); + mli0_load_map(a1); + (*state)++; + break; + case 1: + sub_8111F14(); + (*state)++; + break; + case 2: + sub_8057024(a1); + (*state)++; + break; + case 3: + if (sub_8113748() == TRUE) + return TRUE; + (*state)++; + break; + case 4: + mli4_mapscripts_and_other(); + sub_8057114(); + if (gQuestLogState != QL_STATE_2) + { + sub_80CC534(); + sub_80CC59C(); + } + SetHelpContextForMap(); + (*state)++; + break; + case 5: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 6: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 7: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 8: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 9: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 10: + DrawWholeMapView(); + (*state)++; + break; + case 11: + InitTilesetAnimations(); + (*state)++; + break; + case 12: + if (GetLastUsedWarpMapSectionId() != gMapHeader.regionMapSectionId && MapHasPreviewScreen_HandleQLState2(gMapHeader.regionMapSectionId, MPS_TYPE_FOREST) == TRUE) + { + MapPreview_LoadGfx(gMapHeader.regionMapSectionId); + MapPreview_StartForestTransition(gMapHeader.regionMapSectionId); + } + else if (SHOW_MAP_NAME_ENABLED) + { + ShowMapNamePopup(FALSE); + } + (*state)++; + break; + case 13: + if (map_post_load_hook_exec()) + (*state)++; + break; + case 14: + return TRUE; + } + return FALSE; +} + +static bool32 sub_8056CD8(u8 *state) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + sub_8111F14(); + sub_8057024(FALSE); + sub_8057100(); + sub_8057114(); + (*state)++; + break; + case 1: + (*state)++; + break; + case 2: + sub_8056F08(); + SetHelpContextForMap(); + (*state)++; + break; + case 3: + if (map_post_load_hook_exec()) + (*state)++; + break; + case 4: + return TRUE; + } + return FALSE; +} + +static bool32 map_loading_iteration_2_link(u8 *state) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + FieldClearVBlankHBlankCallbacks(); + (*state)++; + break; + case 1: + sub_8111F14(); + sub_8057024(1); + (*state)++; + break; + case 2: + CreateLinkPlayerSprites(); + sub_8057100(); + SetCameraToTrackGuestPlayer_2(); + SetHelpContextForMap(); + (*state)++; + break; + case 3: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 4: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 5: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 6: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 7: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 8: + DrawWholeMapView(); + (*state)++; + break; + case 9: + InitTilesetAnimations(); + (*state)++; + break; + case 10: + (*state)++; + break; + case 11: + if (gWirelessCommType != 0) + { + LoadWirelessStatusIndicatorSpriteGfx(); + CreateWirelessStatusIndicatorSprite(0, 0); + } + (*state)++; + break; + case 12: + if (map_post_load_hook_exec()) + (*state)++; + break; + case 13: + SetFieldVBlankCallback(); + (*state)++; + return TRUE; + } + + return FALSE; +} + +static void do_load_map_stuff_loop(u8 *state) +{ + while (!load_map_stuff(state, FALSE)) + ; +} + +static void MoveSaveBlocks_ResetHeap_(void) +{ + MoveSaveBlocks_ResetHeap(); +} + +static void sub_8056E80(void) +{ + SetGpuReg(REG_OFFSET_DISPCNT, 0); + ScanlineEffect_Stop(); + + DmaClear16(3, PLTT + 2, PLTT_SIZE - 2); + DmaFillLarge16(3, 0, (void *)(VRAM + 0x0), 0x18000, 0x1000); + ResetOamRange(0, 128); + LoadOam(); +} + +static void sub_8056F08(void) +{ + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + mapdata_load_assets_to_gpu_and_full_redraw(); +} + +static void InitOverworldGraphicsRegisters(void) +{ + ClearScheduledBgCopiesToVram(); + ResetTempTileDataBuffers(); + SetGpuReg(REG_OFFSET_MOSAIC, 0); + SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG_ALL | WININ_WIN0_OBJ | WININ_WIN1_BG_ALL | WININ_WIN1_OBJ); + SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WINOBJ_BG0); + SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(0, 255)); + SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(0, 255)); + SetGpuReg(REG_OFFSET_WIN1H, WIN_RANGE(255, 255)); + SetGpuReg(REG_OFFSET_WIN1V, WIN_RANGE(255, 255)); + SetGpuReg(REG_OFFSET_BLDCNT, gOverworldBackgroundLayerFlags[1] | gOverworldBackgroundLayerFlags[2] | gOverworldBackgroundLayerFlags[3] + | BLDCNT_TGT2_OBJ | BLDCNT_EFFECT_BLEND); + SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(13, 7)); + ScheduleBgCopyTilemapToVram(1); + ScheduleBgCopyTilemapToVram(2); + ScheduleBgCopyTilemapToVram(3); + SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | 0x20 | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON | DISPCNT_WIN1_ON); + ShowBg(0); + ShowBg(1); + ShowBg(2); + ShowBg(3); + ChangeBgX(0, 0, 0); + ChangeBgY(0, 0, 0); + ChangeBgX(1, 0, 0); + ChangeBgY(1, 0, 0); + ChangeBgX(2, 0, 0); + ChangeBgY(2, 0, 0); + ChangeBgX(3, 0, 0); + ChangeBgY(3, 0, 0); +} + +static void sub_8057024(u32 a1) +{ + ResetTasks(); + ResetSpriteData(); + ResetPaletteFade(); + ScanlineEffect_Clear(); + ResetAllPicSprites(); + ResetCameraUpdateInfo(); + InstallCameraPanAheadCallback(); + if (!a1) + InitObjectEventPalettes(0); + else + InitObjectEventPalettes(1); + + FieldEffectActiveListClear(); + StartWeather(); + ResumePausedWeather(); + if (!a1) + SetUpFieldTasks(); + RunOnResumeMapScript(); +} + +static void sub_8057074(void) +{ + gTotalCameraPixelOffsetX = 0; + gTotalCameraPixelOffsetY = 0; + ResetObjectEvents(); + TrySpawnObjectEvents(0, 0); + TryRunOnWarpIntoMapScript(); +} + +static void mli4_mapscripts_and_other(void) +{ + s16 x, y; + struct InitialPlayerAvatarState *player; + + gTotalCameraPixelOffsetX = 0; + gTotalCameraPixelOffsetY = 0; + ResetObjectEvents(); + GetCameraFocusCoords(&x, &y); + player = GetInitialPlayerAvatarState(); + InitPlayerAvatar(x, y, player->direction, gSaveBlock2Ptr->playerGender); + SetPlayerAvatarTransitionFlags(player->transitionFlags); + ResetInitialPlayerAvatarState(); + TrySpawnObjectEvents(0, 0); + TryRunOnWarpIntoMapScript(); +} + +static void sub_8057100(void) +{ + sub_805EDF0(0, 0); + RunOnReturnToFieldMapScript(); +} + +static void sub_8057114(void) +{ + gObjectEvents[gPlayerAvatar.objectEventId].trackedByCamera = TRUE; + InitCameraUpdateCallback(gPlayerAvatar.spriteId); +} + +static void SetCameraToTrackGuestPlayer(void) +{ + InitCameraUpdateCallback(GetSpriteForLinkedPlayer(gLocalLinkPlayerId)); +} + +// Duplicate function. +static void SetCameraToTrackGuestPlayer_2(void) +{ + InitCameraUpdateCallback(GetSpriteForLinkedPlayer(gLocalLinkPlayerId)); +} + +static void sub_8057178(void) +{ + u16 x, y; + GetCameraFocusCoords(&x, &y); + + // This is a hack of some kind; it's undone in sub_8086B14, which is called + // soon after this function. + SetCameraFocusCoords(x + gLocalLinkPlayerId, y); +} + +static void sub_80571A8(void) +{ + u16 i; + u16 x, y; + + GetCameraFocusCoords(&x, &y); + x -= gLocalLinkPlayerId; + + for (i = 0; i < gFieldLinkPlayerCount; i++) + { + SpawnLinkPlayerObjectEvent(i, i + x, y, gLinkPlayers[i].gender); + CreateLinkPlayerSprite(i, gLinkPlayers[i].version); + } + + ClearAllPlayerKeys(); +} + +static void CreateLinkPlayerSprites(void) +{ + u16 i; + for (i = 0; i < gFieldLinkPlayerCount; i++) + CreateLinkPlayerSprite(i, gLinkPlayers[i].version); +} + +// Quest Log + +void sub_805726C(void) +{ + FieldClearVBlankHBlankCallbacks(); + gUnknown_2036E28 = 1; + ScriptContext1_Init(); + ScriptContext2_Disable(); + SetMainCallback1(NULL); + SetMainCallback2(CB2_DoChangeMap); + gMain.savedCallback = sub_80572D8; +} + +void sub_80572A8(void) +{ + FieldClearVBlankHBlankCallbacks(); + gUnknown_2036E28 = 1; + LoadSaveblockMapHeader(); + ScriptContext1_Init(); + ScriptContext2_Disable(); + SetMainCallback1(NULL); + SetMainCallback2(sub_80572D8); +} + +static void sub_80572D8(void) +{ + sub_8057300(&gMain.state); + SetFieldVBlankCallback(); + SetMainCallback1(CB1_Overworld); + SetMainCallback2(CB2_Overworld); +} + +static void sub_8057300(u8 *state) +{ + while (!sub_8057314(state)) + ; +} + +static bool32 sub_8057314(u8 *state) +{ + switch (*state) + { + case 0: + InitOverworldBgs(); + FieldClearVBlankHBlankCallbacks(); + sub_8111F14(); + sub_81113E4(); + sub_8111438(); + if (sub_8110AC8() == 2) + { + gUnknown_2031DE0 = FALSE; + mli0_load_map(FALSE); + } + else + { + gUnknown_2031DE0 = TRUE; + sub_80559A8(); + } + (*state)++; + break; + case 1: + sub_8110FCC(); + (*state)++; + break; + case 2: + sub_8057024(0); + (*state)++; + break; + case 3: + sub_8057100(); + sub_8057114(); + (*state)++; + break; + case 4: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 5: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 6: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 7: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 8: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 9: + DrawWholeMapView(); + (*state)++; + break; + case 10: + InitTilesetAnimations(); + sub_815A540(); + (*state)++; + break; + default: + if (map_post_load_hook_exec()) + return TRUE; + break; + } + return FALSE; +} + +void sub_8057430(void) +{ + FieldClearVBlankHBlankCallbacks(); + StopMapMusic(); + gUnknown_2036E28 = 3; + ResetSafariZoneFlag_(); + LoadSaveblockMapHeader(); + LoadSaveblockObjEventScripts(); + UnfreezeObjectEvents(); + sub_8054E40(); + InitMapFromSavedGame(); + PlayTimeCounter_Start(); + ScriptContext1_Init(); + gUnknown_2031DE0 = TRUE; + if (UseContinueGameWarp() == TRUE) + { + ClearContinueGameWarpStatus(); + SetWarpDestinationToContinueGameWarp(); + WarpIntoMap(); + SetMainCallback2(CB2_LoadMap); + } + else + { + SetMainCallback1(CB1_Overworld); + CB2_ReturnToField(); + } +} + +// Credits + +void Overworld_CreditsMainCB(void) +{ + bool8 fading = !!gPaletteFade.active; + if (fading) + SetVBlankCallback(NULL); + RunTasks(); + AnimateSprites(); + sub_805ACF0(); + UpdateCameraPanning(); + BuildOamBuffer(); + UpdatePaletteFade(); + UpdateTilesetAnimations(); + DoScheduledBgTilemapCopiesToVram(); + if (fading) + SetFieldVBlankCallback(); +} + +static bool8 FieldCB2_Credits_WaitFade(void) +{ + if (gPaletteFade.active) + return TRUE; + else + return FALSE; +} + +bool32 Overworld_DoScrollSceneForCredits(u8 *state_p, const struct CreditsOverworldCmd * script, u8 a2) +{ + sCreditsOverworld_Script = script; + gUnknown_2036E28 = a2; + return SetUpScrollSceneForCredits(state_p, 0); +} + +static bool32 SetUpScrollSceneForCredits(u8 *state, u8 unused) +{ + struct WarpData warp; + switch (*state) + { + case 0: + sCreditsOverworld_CmdIndex = 0; + sCreditsOverworld_CmdLength = 0; + (*state)++; + return FALSE; + case 1: + warp.mapGroup = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2; + warp.mapNum = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4; + warp.warpId = -1; + sCreditsOverworld_CmdIndex++; + warp.x = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0; + warp.y = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2; + sWarpDestination = warp; + sCreditsOverworld_CmdLength = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4; + WarpIntoMap(); + gPaletteFade.bufferTransferDisabled = TRUE; + ScriptContext1_Init(); + ScriptContext2_Disable(); + SetMainCallback1(NULL); + gFieldCallback2 = FieldCB2_Credits_WaitFade; + gMain.state = 0; + (*state)++; + return FALSE; + case 2: + if (MapLdr_Credits()) + { + (*state)++; + return FALSE; + } + break; + case 3: + gFieldCamera.callback = CameraCB_CreditsPan; + SetFieldVBlankCallback(); + *state = 0; + return TRUE; + } + return FALSE; +} + +static bool8 MapLdr_Credits(void) +{ + u8 *state = &gMain.state; + switch (*state) + { + case 0: + InitOverworldBgs_NoResetHeap(); + mli0_load_map(FALSE); + (*state)++; + break; + case 1: + ScanlineEffect_Clear(); + ResetAllPicSprites(); + ResetCameraUpdateInfo(); + InstallCameraPanAheadCallback(); + FieldEffectActiveListClear(); + StartWeather(); + ResumePausedWeather(); + SetUpFieldTasks(); + RunOnResumeMapScript(); + (*state)++; + break; + case 2: + InitCurrentFlashLevelScanlineEffect(); + InitOverworldGraphicsRegisters(); + (*state)++; + break; + case 3: + move_tilemap_camera_to_upper_left_corner(); + (*state)++; + break; + case 4: + copy_map_tileset1_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 5: + copy_map_tileset2_to_vram(gMapHeader.mapLayout); + (*state)++; + break; + case 6: + if (FreeTempTileDataBuffersIfPossible() != TRUE) + { + apply_map_tileset1_tileset2_palette(gMapHeader.mapLayout); + (*state)++; + } + break; + case 7: + DrawWholeMapView(); + (*state)++; + break; + case 8: + InitTilesetAnimations(); + gPaletteFade.bufferTransferDisabled = FALSE; + FadeSelectedPals(FADE_FROM_BLACK, 0, 0x3FFFFFFF); + (*state)++; + break; + default: + return TRUE; + } + return FALSE; +} + +static void CameraCB_CreditsPan(struct CameraObject * camera) +{ + if (sCreditsOverworld_CmdLength == 0) + { + sCreditsOverworld_CmdIndex++; + switch (sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0) + { + case CREDITSOVWLDCMD_FC: + case CREDITSOVWLDCMD_LOADMAP: + return; + case CREDITSOVWLDCMD_FF: + camera->movementSpeedX = 0; + camera->movementSpeedY = 0; + camera->callback = NULL; + CreateTask(Task_OvwldCredits_FadeOut, 0); + return; + case CREDITSOVWLDCMD_FB: + camera->movementSpeedX = 0; + camera->movementSpeedY = 0; + camera->callback = NULL; + break; + case CREDITSOVWLDCMD_END: + camera->movementSpeedX = 0; + camera->movementSpeedY = 0; + camera->callback = NULL; + return; + default: + sCreditsOverworld_CmdLength = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_4; + camera->movementSpeedX = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0; + camera->movementSpeedY = sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_2; + break; + } + } + if (sCreditsOverworld_Script[sCreditsOverworld_CmdIndex].unk_0 == 0xFF) + { + camera->movementSpeedX = 0; + camera->movementSpeedY = 0; + } + else + sCreditsOverworld_CmdLength--; +} + +static void Task_OvwldCredits_FadeOut(u8 taskId) +{ + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB_BLACK); + gTasks[taskId].func = Task_OvwldCredits_WaitFade; +} + +static void Task_OvwldCredits_WaitFade(u8 taskId) +{ + if (!gPaletteFade.active) + { + CleanupOverworldWindowsAndTilemaps(); + SetMainCallback2(CB2_LoadMap); + DestroyTask(taskId); + } +} + +// Link related + +static u8 (*const sLinkPlayerMovementModes[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8) = { + MovementEventModeCB_Normal, // MOVEMENT_MODE_FREE + MovementEventModeCB_Ignored, // MOVEMENT_MODE_FROZEN + MovementEventModeCB_Normal_2, // MOVEMENT_MODE_SCRIPTED +}; + +// These handlers return TRUE if the movement was scripted and successful, and FALSE otherwise. +static bool8 (*const sLinkPlayerFacingHandlers[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *, u8) = { + FacingHandler_DoNothing, + FacingHandler_DpadMovement, + FacingHandler_DpadMovement, + FacingHandler_DpadMovement, + FacingHandler_DpadMovement, + FacingHandler_DoNothing, + FacingHandler_DoNothing, + FacingHandler_ForcedFacingChange, + FacingHandler_ForcedFacingChange, + FacingHandler_ForcedFacingChange, + FacingHandler_ForcedFacingChange, +}; + +// These handlers are run after an attempted movement. +static void (*const sMovementStatusHandler[])(struct LinkPlayerObjectEvent *, struct ObjectEvent *) = { + // FALSE: + MovementStatusHandler_EnterFreeMode, + // TRUE: + MovementStatusHandler_TryAdvanceScript, +}; + +static void CB1_UpdateLinkState(void) +{ + if (gWirelessCommType == 0 || !IsRfuRecvQueueEmpty() || !IsSendingKeysToLink()) + { + u8 selfId = gLocalLinkPlayerId; + UpdateAllLinkPlayers(gLinkPartnersHeldKeys, selfId); + + // Note: Because guestId is between 0 and 4, while the smallest key code is + // LINK_KEY_CODE_EMPTY, this is functionally equivalent to `sPlayerKeyInterceptCallback(0)`. + // It is expecting the callback to be KeyInterCB_SelfIdle, and that will + // completely ignore any input parameters. + // + // UpdateHeldKeyCode performs a sanity check on its input; if + // sPlayerKeyInterceptCallback echoes back the argument, which is selfId, then + // it'll use LINK_KEY_CODE_EMPTY instead. + // + // Note 2: There are some key intercept callbacks that treat the key as a player + // ID. It's so hacky. + UpdateHeldKeyCode(sPlayerKeyInterceptCallback(selfId)); + ClearAllPlayerKeys(); + } +} + +static void ResetAllMultiplayerState(void) +{ + ResetAllTradingStates(); + SetKeyInterceptCallback(KeyInterCB_SelfIdle); +} + +static void ClearAllPlayerKeys(void) +{ + ResetPlayerHeldKeys(gLinkPartnersHeldKeys); +} + +static void SetKeyInterceptCallback(KeyInterCB func) +{ + sRfuKeepAliveTimer = 0; + sPlayerKeyInterceptCallback = func; +} + +// Once every ~60 frames, if the link state hasn't changed (timer reset by calls +// to SetKeyInterceptCallback), it does a bunch of sanity checks on the connection. +// I'm not sure if sRfuKeepAliveTimer is reset in the process, though; rfu stuff is +// still undocumented. +static void CheckRfuKeepAliveTimer(void) +{ + if (gWirelessCommType != 0 && ++sRfuKeepAliveTimer > 60) + LinkRfu_FatalError(); +} + +static void ResetAllTradingStates(void) +{ + s32 i; + for (i = 0; i < 4; i++) + sPlayerTradingStates[i] = PLAYER_TRADING_STATE_IDLE; +} + +// Returns true if all connected players are in tradingState. +static bool32 AreAllPlayersInTradingState(u16 tradingState) +{ + s32 i; + s32 count = gFieldLinkPlayerCount; + + for (i = 0; i < count; i++) + if (sPlayerTradingStates[i] != tradingState) + return FALSE; + return TRUE; +} + +static bool32 IsAnyPlayerInTradingState(u16 tradingState) +{ + s32 i; + s32 count = gFieldLinkPlayerCount; + + for (i = 0; i < count; i++) + if (sPlayerTradingStates[i] == tradingState) + return TRUE; + return FALSE; +} + +static void HandleLinkPlayerKeyInput(u32 playerId, u16 key, struct TradeRoomPlayer *trainer, u16 *forceFacing) +{ + const u8 *script; + + if (sPlayerTradingStates[playerId] == PLAYER_TRADING_STATE_IDLE) + { + script = TryGetTileEventScript(trainer); + if (script) + { + *forceFacing = GetDirectionForEventScript(script); + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + sub_80581DC(script); + } + return; + } + if (IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + sub_8058230(); + } + return; + } + + switch (key) + { + case LINK_KEY_CODE_START_BUTTON: + if (sub_8058004(trainer)) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + InitLinkRoomStartMenuScript(); + } + } + break; + case LINK_KEY_CODE_DPAD_DOWN: + if (PlayerIsAtSouthExit(trainer) == TRUE) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + CreateConfirmLeaveTradeRoomPrompt(); + } + } + break; + case LINK_KEY_CODE_A_BUTTON: + script = TryInteractWithPlayer(trainer); + if (script) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + InitMenuBasedScript(script); + } + } + break; + case LINK_KEY_CODE_HANDLE_RECV_QUEUE: + if (sub_8057FEC(trainer)) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToRecvQueue); + sub_80581BC(); + } + } + break; + case LINK_KEY_CODE_HANDLE_SEND_QUEUE: + if (sub_8057FEC(trainer)) + { + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + if (trainer->isLocalPlayer) + { + SetKeyInterceptCallback(KeyInterCB_DeferToSendQueue); + sub_80581BC(); + } + } + break; + } + } + + switch (key) + { + case LINK_KEY_CODE_EXIT_ROOM: + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_EXITING_ROOM; + break; + case LINK_KEY_CODE_UNK_2: + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_UNK_2; + break; + case LINK_KEY_CODE_UNK_4: + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_IDLE; + if (trainer->isLocalPlayer) + SetKeyInterceptCallback(KeyInterCB_SelfIdle); + break; + case LINK_KEY_CODE_UNK_7: + if (sPlayerTradingStates[playerId] == PLAYER_TRADING_STATE_UNK_2) + sPlayerTradingStates[playerId] = PLAYER_TRADING_STATE_BUSY; + break; + } +} + +static void UpdateAllLinkPlayers(u16 *keys, s32 selfId) +{ + struct TradeRoomPlayer trainer; + s32 i; + + for (i = 0; i < MAX_LINK_PLAYERS; i++) + { + u8 key = keys[i]; + u16 setFacing = FACING_NONE; + LoadTradeRoomPlayer(i, selfId, &trainer); + HandleLinkPlayerKeyInput(i, key, &trainer, &setFacing); + if (sPlayerTradingStates[i] == PLAYER_TRADING_STATE_IDLE) + setFacing = GetDirectionForDpadKey(key); + SetPlayerFacingDirection(i, setFacing); + } +} + +static void UpdateHeldKeyCode(u16 key) +{ + if (key >= LINK_KEY_CODE_EMPTY && key < LINK_KEY_CODE_UNK_8) + gHeldKeyCodeToSend = key; + else + gHeldKeyCodeToSend = LINK_KEY_CODE_EMPTY; + + if (gWirelessCommType != 0 + && GetLinkSendQueueLength() > 1 + && IsUpdateLinkStateCBActive() == TRUE + && IsSendingKeysToLink() == TRUE) + { + switch (key) + { + case LINK_KEY_CODE_EMPTY: + case LINK_KEY_CODE_DPAD_DOWN: + case LINK_KEY_CODE_DPAD_UP: + case LINK_KEY_CODE_DPAD_LEFT: + case LINK_KEY_CODE_DPAD_RIGHT: + case LINK_KEY_CODE_START_BUTTON: + case LINK_KEY_CODE_A_BUTTON: + gHeldKeyCodeToSend = LINK_KEY_CODE_NULL; + break; + } + } +} + +static u16 KeyInterCB_ReadButtons(u32 key) +{ + if (JOY_HELD(DPAD_UP)) + return LINK_KEY_CODE_DPAD_UP; + else if (JOY_HELD(DPAD_DOWN)) + return LINK_KEY_CODE_DPAD_DOWN; + else if (JOY_HELD(DPAD_LEFT)) + return LINK_KEY_CODE_DPAD_LEFT; + else if (JOY_HELD(DPAD_RIGHT)) + return LINK_KEY_CODE_DPAD_RIGHT; + else if (JOY_NEW(START_BUTTON)) + return LINK_KEY_CODE_START_BUTTON; + else if (JOY_NEW(A_BUTTON)) + return LINK_KEY_CODE_A_BUTTON; + else + return LINK_KEY_CODE_EMPTY; +} + +static u16 GetDirectionForDpadKey(u16 a1) +{ + switch (a1) + { + case LINK_KEY_CODE_DPAD_RIGHT: + return FACING_RIGHT; + case LINK_KEY_CODE_DPAD_LEFT: + return FACING_LEFT; + case LINK_KEY_CODE_DPAD_UP: + return FACING_UP; + case LINK_KEY_CODE_DPAD_DOWN: + return FACING_DOWN; + default: + return FACING_NONE; + } +} + +// Overwrites the keys with 0x11 +static void ResetPlayerHeldKeys(u16 *keys) +{ + s32 i; + for (i = 0; i < 4; i++) + keys[i] = LINK_KEY_CODE_EMPTY; +} + +static u16 KeyInterCB_SelfIdle(u32 key) +{ + if (ScriptContext2_IsEnabled() == TRUE) + return LINK_KEY_CODE_EMPTY; + if (GetLinkRecvQueueLength() > 4) + return LINK_KEY_CODE_HANDLE_RECV_QUEUE; + if (GetLinkSendQueueLength() <= 4) + return KeyInterCB_ReadButtons(key); + return LINK_KEY_CODE_HANDLE_SEND_QUEUE; +} + +static u16 sub_8057D98(u32 key) +{ + CheckRfuKeepAliveTimer(); + return LINK_KEY_CODE_EMPTY; +} + +// Ignore the player's inputs as long as there is an event script +// in ScriptContext2. +static u16 KeyInterCB_DeferToEventScript(u32 key) +{ + u16 retVal; + if (ScriptContext2_IsEnabled() == TRUE) + { + retVal = LINK_KEY_CODE_EMPTY; + } + else + { + retVal = LINK_KEY_CODE_UNK_4; + SetKeyInterceptCallback(sub_8057D98); + } + return retVal; +} + +// Ignore the player's inputs as long as there are events being recived. +static u16 KeyInterCB_DeferToRecvQueue(u32 key) +{ + u16 retVal; + if (GetLinkRecvQueueLength() > 2) + { + retVal = LINK_KEY_CODE_EMPTY; + } + else + { + retVal = LINK_KEY_CODE_UNK_4; + ScriptContext2_Disable(); + SetKeyInterceptCallback(sub_8057D98); + } + return retVal; +} + +// Ignore the player's inputs as long as there are events being sent. +static u16 KeyInterCB_DeferToSendQueue(u32 key) +{ + u16 retVal; + if (GetLinkSendQueueLength() > 2) + { + retVal = LINK_KEY_CODE_EMPTY; + } + else + { + retVal = LINK_KEY_CODE_UNK_4; + ScriptContext2_Disable(); + SetKeyInterceptCallback(sub_8057D98); + } + return retVal; +} + +static u16 KeyInterCB_DoNothingAndKeepAlive(u32 key) +{ + CheckRfuKeepAliveTimer(); + return LINK_KEY_CODE_EMPTY; +} + +static u16 sub_8057E1C(u32 keyOrPlayerId) +{ + if (sPlayerTradingStates[keyOrPlayerId] == PLAYER_TRADING_STATE_UNK_2) + { + if (JOY_NEW(B_BUTTON)) + { + SetKeyInterceptCallback(KeyInterCB_DoNothingAndKeepAlive); + return LINK_KEY_CODE_UNK_7; + } + else + { + return LINK_KEY_CODE_EMPTY; + } + } + else + { + CheckRfuKeepAliveTimer(); + return LINK_KEY_CODE_EMPTY; + } +} + +static u16 sub_8057E58(u32 a1) +{ + SetKeyInterceptCallback(sub_8057E1C); + return LINK_KEY_CODE_UNK_2; +} + +static u16 KeyInterCB_SendNothing(u32 key) +{ + return LINK_KEY_CODE_EMPTY; +} + +static u16 KeyInterCB_WaitForPlayersToExit(u32 keyOrPlayerId) +{ + // keyOrPlayerId could be any keycode. This callback does no sanity checking + // on the size of the key. It's assuming that it is being called from + // CB1_UpdateLinkState. + if (sPlayerTradingStates[keyOrPlayerId] != PLAYER_TRADING_STATE_EXITING_ROOM) + CheckRfuKeepAliveTimer(); + if (AreAllPlayersInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE) + { + ScriptContext1_SetupScript(CableClub_EventScript_DoLinkRoomExit); + SetKeyInterceptCallback(KeyInterCB_SendNothing); + } + return LINK_KEY_CODE_EMPTY; +} + +static u16 KeyInterCB_SendExitRoomKey(u32 key) +{ + SetKeyInterceptCallback(KeyInterCB_WaitForPlayersToExit); + return LINK_KEY_CODE_EXIT_ROOM; +} + +// Duplicate function. +static u16 KeyInterCB_SendNothing_2(u32 key) +{ + return LINK_KEY_CODE_EMPTY; +} + +u32 sub_8057EC0(void) +{ + if (IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM) == TRUE) + return 2; + if (sPlayerKeyInterceptCallback == sub_8057E1C && sPlayerTradingStates[gLocalLinkPlayerId] != PLAYER_TRADING_STATE_UNK_2) + return 0; + if (sPlayerKeyInterceptCallback == KeyInterCB_DoNothingAndKeepAlive && sPlayerTradingStates[gLocalLinkPlayerId] == PLAYER_TRADING_STATE_BUSY) + return 2; + if (AreAllPlayersInTradingState(PLAYER_TRADING_STATE_UNK_2) != FALSE) + return 1; + return 0; +} + +static bool32 sub_8057F28(void) +{ + return IsAnyPlayerInTradingState(PLAYER_TRADING_STATE_EXITING_ROOM); +} + +u16 sub_8057F34(void) +{ + SetKeyInterceptCallback(sub_8057E58); + return 0; +} + +u16 sub_8057F48(void) +{ + SetKeyInterceptCallback(KeyInterCB_DeferToEventScript); + return 0; +} + +// The exit room key will be sent at the next opportunity. +// The return value is meaningless. +u16 QueueExitLinkRoomKey(void) +{ + SetKeyInterceptCallback(KeyInterCB_SendExitRoomKey); + return 0; +} + +u16 sub_8057F70(void) +{ + SetKeyInterceptCallback(KeyInterCB_SendNothing_2); + return 0; +} + +static void LoadTradeRoomPlayer(s32 linkPlayerId, s32 myPlayerId, struct TradeRoomPlayer *trainer) +{ + s16 x, y; + + trainer->playerId = linkPlayerId; + trainer->isLocalPlayer = (linkPlayerId == myPlayerId) ? TRUE : FALSE; + trainer->c = gLinkPlayerObjectEvents[linkPlayerId].movementMode; + trainer->facing = GetLinkPlayerFacingDirection(linkPlayerId); + GetLinkPlayerCoords(linkPlayerId, &x, &y); + trainer->pos.x = x; + trainer->pos.y = y; + trainer->pos.height = GetLinkPlayerElevation(linkPlayerId); + trainer->field_C = MapGridGetMetatileBehaviorAt(x, y); +} + +static bool32 sub_8057FEC(struct TradeRoomPlayer *player) +{ + u8 v1 = player->c; + if (v1 == MOVEMENT_MODE_SCRIPTED || v1 == MOVEMENT_MODE_FREE) + return TRUE; + else + return FALSE; +} + +// Duplicate function. +static bool32 sub_8058004(struct TradeRoomPlayer *player) +{ + u8 v1 = player->c; + if (v1 == MOVEMENT_MODE_SCRIPTED || v1 == MOVEMENT_MODE_FREE) + return TRUE; + else + return FALSE; +} + +static const u8 *TryGetTileEventScript(struct TradeRoomPlayer *player) +{ + if (player->c != MOVEMENT_MODE_SCRIPTED) + return FACING_NONE; + return GetCoordEventScriptAtMapPosition(&player->pos); +} + +static bool32 PlayerIsAtSouthExit(struct TradeRoomPlayer *player) +{ + if (player->c != MOVEMENT_MODE_SCRIPTED && player->c != MOVEMENT_MODE_FREE) + return FALSE; + else if (!MetatileBehavior_IsSouthArrowWarp(player->field_C)) + return FALSE; + else if (player->facing != DIR_SOUTH) + return FALSE; + else + return TRUE; +} + +static const u8 *TryInteractWithPlayer(struct TradeRoomPlayer *player) +{ + struct MapPosition otherPlayerPos; + u8 linkPlayerId; + + if (player->c != MOVEMENT_MODE_FREE && player->c != MOVEMENT_MODE_SCRIPTED) + return FACING_NONE; + + otherPlayerPos = player->pos; + otherPlayerPos.x += gDirectionToVectors[player->facing].x; + otherPlayerPos.y += gDirectionToVectors[player->facing].y; + otherPlayerPos.height = 0; + linkPlayerId = GetLinkPlayerIdAt(otherPlayerPos.x, otherPlayerPos.y); + + if (linkPlayerId != 4) + { + if (!player->isLocalPlayer) + return CableClub_EventScript_TooBusyToNotice; + else if (sPlayerTradingStates[linkPlayerId] != PLAYER_TRADING_STATE_IDLE) + return CableClub_EventScript_TooBusyToNotice; + else if (!GetSeeingLinkPlayerCardMsg(linkPlayerId)) + return CableClub_EventScript_ReadTrainerCard; + else + return CableClub_EventScript_ReadTrainerCardColored; + } + + return GetInteractedLinkPlayerScript(&otherPlayerPos, player->field_C, player->facing); +} + +// This returns which direction to force the player to look when one of +// these event scripts runs. +static u16 GetDirectionForEventScript(const u8 *script) +{ + if (script == BattleColosseum_4P_EventScript_PlayerSpot0) + return FACING_FORCED_RIGHT; + else if (script == BattleColosseum_4P_EventScript_PlayerSpot1) + return FACING_FORCED_LEFT; + else if (script == BattleColosseum_4P_EventScript_PlayerSpot2) + return FACING_FORCED_RIGHT; + else if (script == BattleColosseum_4P_EventScript_PlayerSpot3) + return FACING_FORCED_LEFT; + else if (script == RecordCenter_EventScript_Spot0) + return FACING_FORCED_RIGHT; + else if (script == RecordCenter_EventScript_Spot1) + return FACING_FORCED_LEFT; + else if (script == RecordCenter_EventScript_Spot2) + return FACING_FORCED_RIGHT; + else if (script == RecordCenter_EventScript_Spot3) + return FACING_FORCED_LEFT; + else if (script == BattleColosseum_2P_EventScript_PlayerSpot0) + return FACING_FORCED_RIGHT; + else if (script == BattleColosseum_2P_EventScript_PlayerSpot1) + return FACING_FORCED_LEFT; + else if (script == TradeCenter_EventScript_Chair0) + return FACING_FORCED_RIGHT; + else if (script == TradeCenter_EventScript_Chair1) + return FACING_FORCED_LEFT; + else + return FACING_NONE; +} + +static void sub_80581BC(void) +{ + ScriptContext2_Enable(); +} + +static void InitLinkRoomStartMenuScript(void) +{ + PlaySE(SE_WIN_OPEN); + ShowStartMenu(); + ScriptContext2_Enable(); +} + +static void sub_80581DC(const u8 *script) +{ + PlaySE(SE_SELECT); + ScriptContext1_SetupScript(script); + ScriptContext2_Enable(); +} + +static void CreateConfirmLeaveTradeRoomPrompt(void) +{ + PlaySE(SE_WIN_OPEN); + ScriptContext1_SetupScript(TradeCenter_ConfirmLeaveRoom); + ScriptContext2_Enable(); +} + +static void InitMenuBasedScript(const u8 *script) +{ + PlaySE(SE_SELECT); + ScriptContext1_SetupScript(script); + ScriptContext2_Enable(); +} + +static void sub_8058230(void) +{ + ScriptContext1_SetupScript(TradeCenter_TerminateLink); + ScriptContext2_Enable(); +} + +bool32 sub_8058244(void) +{ + if (!IsUpdateLinkStateCBActive()) + return FALSE; + if (GetLinkRecvQueueLength() >= 3) + gUnknown_3000E88 = TRUE; + else + gUnknown_3000E88 = FALSE; + return gUnknown_3000E88; +} + +bool32 sub_8058274(void) +{ + u8 temp; + + if (GetLinkRecvQueueLength() < 2) + return FALSE; + else if (IsUpdateLinkStateCBActive() != TRUE) + return FALSE; + else if (IsSendingKeysToLink() != TRUE) + return FALSE; + else if (sPlayerKeyInterceptCallback == KeyInterCB_DeferToRecvQueue) + return TRUE; + else if (sPlayerKeyInterceptCallback != KeyInterCB_DeferToEventScript) + return FALSE; + + temp = gUnknown_3000E88; + gUnknown_3000E88 = FALSE; + + if (temp == TRUE) + return TRUE; + else if (gPaletteFade.active && gPaletteFade.softwareFadeFinishing) + return TRUE; + else + return FALSE; +} + +bool32 sub_80582E0(void) +{ + if (GetLinkSendQueueLength() < 2) + return FALSE; + else if (IsUpdateLinkStateCBActive() != TRUE) + return FALSE; + else if (IsSendingKeysToLink() != TRUE) + return FALSE; + else if (sPlayerKeyInterceptCallback == KeyInterCB_DeferToSendQueue) + return TRUE; + else + return FALSE; +} + +bool32 sub_8058318(void) +{ + if (gWirelessCommType != 0) + return FALSE; + else if (!IsSendingKeysToLink()) + return FALSE; + else + return TRUE; +} + +static u32 GetLinkSendQueueLength(void) +{ + if (gWirelessCommType != 0) + return Rfu.sendQueue.count; + else + return gLink.sendQueue.count; +} + +static void ZeroLinkPlayerObjectEvent(struct LinkPlayerObjectEvent *linkPlayerObjEvent) +{ + memset(linkPlayerObjEvent, 0, sizeof(struct LinkPlayerObjectEvent)); +} + +void ClearLinkPlayerObjectEvents(void) +{ + memset(gLinkPlayerObjectEvents, 0, sizeof(gLinkPlayerObjectEvents)); +} + +static void ZeroObjectEvent(struct ObjectEvent *objEvent) +{ + memset(objEvent, 0, sizeof(struct ObjectEvent)); +} + +static void SpawnLinkPlayerObjectEvent(u8 linkPlayerId, s16 x, s16 y, u8 a4) +{ + u8 objEventId = GetFirstInactiveObjectEventId(); + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId]; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + + ZeroLinkPlayerObjectEvent(linkPlayerObjEvent); + ZeroObjectEvent(objEvent); + + linkPlayerObjEvent->active = TRUE; + linkPlayerObjEvent->linkPlayerId = linkPlayerId; + linkPlayerObjEvent->objEventId = objEventId; + linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FREE; + + objEvent->active = TRUE; + objEvent->singleMovementActive = a4; + objEvent->range.as_byte = 2; + objEvent->spriteId = MAX_SPRITES; + + InitLinkPlayerObjectEventPos(objEvent, x, y); +} + +static void InitLinkPlayerObjectEventPos(struct ObjectEvent *objEvent, s16 x, s16 y) +{ + objEvent->currentCoords.x = x; + objEvent->currentCoords.y = y; + objEvent->previousCoords.x = x; + objEvent->previousCoords.y = y; + SetSpritePosToMapCoords(x, y, &objEvent->initialCoords.x, &objEvent->initialCoords.y); + objEvent->initialCoords.x += 8; + ObjectEventUpdateZCoord(objEvent); +} + +static void sub_8058488(u8 linkPlayerId, u8 a2) +{ + if (gLinkPlayerObjectEvents[linkPlayerId].active) + { + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + objEvent->range.as_byte = a2; + } +} + +static void sub_80584B8(u8 linkPlayerId) +{ + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId]; + u8 objEventId = linkPlayerObjEvent->objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + if (objEvent->spriteId != MAX_SPRITES) + DestroySprite(&gSprites[objEvent->spriteId]); + linkPlayerObjEvent->active = FALSE; + objEvent->active = FALSE; +} + +// Returns the spriteId corresponding to this player. +static u8 GetSpriteForLinkedPlayer(u8 linkPlayerId) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + return objEvent->spriteId; +} + +static void GetLinkPlayerCoords(u8 linkPlayerId, u16 *x, u16 *y) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + *x = objEvent->currentCoords.x; + *y = objEvent->currentCoords.y; +} + +static u8 GetLinkPlayerFacingDirection(u8 linkPlayerId) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + return objEvent->range.as_byte; +} + +static u8 GetLinkPlayerElevation(u8 linkPlayerId) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + return objEvent->currentElevation; +} + +static s32 sub_8058590(u8 linkPlayerId) +{ + u8 objEventId = gLinkPlayerObjectEvents[linkPlayerId].objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + return 16 - (s8)objEvent->directionSequenceIndex; +} + +static u8 GetLinkPlayerIdAt(s16 x, s16 y) +{ + u8 i; + for (i = 0; i < MAX_LINK_PLAYERS; i++) + { + if (gLinkPlayerObjectEvents[i].active + && (gLinkPlayerObjectEvents[i].movementMode == 0 || gLinkPlayerObjectEvents[i].movementMode == 2)) + { + struct ObjectEvent *objEvent = &gObjectEvents[gLinkPlayerObjectEvents[i].objEventId]; + if (objEvent->currentCoords.x == x && objEvent->currentCoords.y == y) + return i; + } + } + return 4; +} + +static void SetPlayerFacingDirection(u8 linkPlayerId, u8 facing) +{ + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId]; + u8 objEventId = linkPlayerObjEvent->objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + + if (linkPlayerObjEvent->active) + { + if (facing > FACING_FORCED_RIGHT) + { + objEvent->triggerGroundEffectsOnMove = TRUE; + } + else + { + // This is a hack to split this code onto two separate lines, without declaring a local variable. + // C++ style inline variables would be nice here. +#define TEMP sLinkPlayerMovementModes[linkPlayerObjEvent->movementMode](linkPlayerObjEvent, objEvent, facing) + + sMovementStatusHandler[TEMP](linkPlayerObjEvent, objEvent); + + // Clean up the hack. +#undef TEMP + } + } +} + +static u8 MovementEventModeCB_Normal(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + return sLinkPlayerFacingHandlers[a3](linkPlayerObjEvent, objEvent, a3); +} + +static u8 MovementEventModeCB_Ignored(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + return FACING_UP; +} + +// Duplicate Function +static u8 MovementEventModeCB_Normal_2(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + return sLinkPlayerFacingHandlers[a3](linkPlayerObjEvent, objEvent, a3); +} + +static bool8 FacingHandler_DoNothing(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + return FALSE; +} + +static bool8 FacingHandler_DpadMovement(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + s16 x, y; + + objEvent->range.as_byte = FlipVerticalAndClearForced(a3, objEvent->range.as_byte); + ObjectEventMoveDestCoords(objEvent, objEvent->range.as_byte, &x, &y); + + if (LinkPlayerDetectCollision(linkPlayerObjEvent->objEventId, objEvent->range.as_byte, x, y)) + { + return FALSE; + } + else + { + objEvent->directionSequenceIndex = 16; + ShiftObjectEventCoords(objEvent, x, y); + ObjectEventUpdateZCoord(objEvent); + return TRUE; + } +} + +static bool8 FacingHandler_ForcedFacingChange(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent, u8 a3) +{ + objEvent->range.as_byte = FlipVerticalAndClearForced(a3, objEvent->range.as_byte); + return FALSE; +} + +// This is called every time a free movement happens. Most of the time it's a No-Op. +static void MovementStatusHandler_EnterFreeMode(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent) +{ + linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FREE; +} + +static void MovementStatusHandler_TryAdvanceScript(struct LinkPlayerObjectEvent *linkPlayerObjEvent, struct ObjectEvent *objEvent) +{ + objEvent->directionSequenceIndex--; + linkPlayerObjEvent->movementMode = MOVEMENT_MODE_FROZEN; + MoveCoords(objEvent->range.as_byte, &objEvent->initialCoords.x, &objEvent->initialCoords.y); + if (!objEvent->directionSequenceIndex) + { + ShiftStillObjectEventCoords(objEvent); + linkPlayerObjEvent->movementMode = MOVEMENT_MODE_SCRIPTED; + } +} + +// Flip Up/Down facing codes. If newFacing doesn't specify a direction, default +// to oldFacing. Note that this clears also the "FORCED" part of the facing code, +// even for Left/Right codes. +static u8 FlipVerticalAndClearForced(u8 newFacing, u8 oldFacing) +{ + switch (newFacing) + { + case FACING_UP: + case FACING_FORCED_UP: + return DIR_NORTH; + case FACING_DOWN: + case FACING_FORCED_DOWN: + return DIR_SOUTH; + case FACING_LEFT: + case FACING_FORCED_LEFT: + return DIR_WEST; + case FACING_RIGHT: + case FACING_FORCED_RIGHT: + return DIR_EAST; + } + return oldFacing; +} + +static bool8 LinkPlayerDetectCollision(u8 selfObjEventId, u8 a2, s16 x, s16 y) +{ + u8 i; + for (i = 0; i < 16; i++) + { + if (i != selfObjEventId) + { + if ((gObjectEvents[i].currentCoords.x == x && gObjectEvents[i].currentCoords.y == y) + || (gObjectEvents[i].previousCoords.x == x && gObjectEvents[i].previousCoords.y == y)) + { + return TRUE; + } + } + } + return MapGridIsImpassableAt(x, y); +} + +static void CreateLinkPlayerSprite(u8 linkPlayerId, u8 gameVersion) +{ + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[linkPlayerId]; + u8 objEventId = linkPlayerObjEvent->objEventId; + struct ObjectEvent *objEvent = &gObjectEvents[objEventId]; + struct Sprite *sprite; + + if (linkPlayerObjEvent->active) + { + if (gameVersion == VERSION_FIRE_RED || gameVersion == VERSION_LEAF_GREEN) + { + objEvent->spriteId = AddPseudoObjectEvent( + GetRivalAvatarGraphicsIdByStateIdAndGender(PLAYER_AVATAR_STATE_NORMAL, objEvent->singleMovementActive), + SpriteCB_LinkPlayer, 0, 0, 0); + } + else + { + objEvent->spriteId = AddPseudoObjectEvent(GetRSAvatarGraphicsIdByGender(objEvent->singleMovementActive), SpriteCB_LinkPlayer, 0, 0, 0); + } + + sprite = &gSprites[objEvent->spriteId]; + sprite->coordOffsetEnabled = TRUE; + sprite->data[0] = linkPlayerId; + objEvent->triggerGroundEffectsOnMove = FALSE; + } +} + +static void SpriteCB_LinkPlayer(struct Sprite *sprite) +{ + struct LinkPlayerObjectEvent *linkPlayerObjEvent = &gLinkPlayerObjectEvents[sprite->data[0]]; + struct ObjectEvent *objEvent = &gObjectEvents[linkPlayerObjEvent->objEventId]; + sprite->pos1.x = objEvent->initialCoords.x; + sprite->pos1.y = objEvent->initialCoords.y; + SetObjectSubpriorityByZCoord(objEvent->previousElevation, sprite, 1); + sprite->oam.priority = ZCoordToPriority(objEvent->previousElevation); + + if (!linkPlayerObjEvent->movementMode != MOVEMENT_MODE_FREE) + StartSpriteAnim(sprite, GetFaceDirectionAnimNum(objEvent->range.as_byte)); + else + StartSpriteAnimIfDifferent(sprite, GetMoveDirectionAnimNum(objEvent->range.as_byte)); + + UpdateObjectEventSpriteVisibility(sprite, 0); + if (objEvent->triggerGroundEffectsOnMove) + { + sprite->invisible = ((sprite->data[7] & 4) >> 2); + sprite->data[7]++; + } +} diff --git a/src/party_menu_specials.c b/src/party_menu_specials.c index aba11a534..48406da9a 100644 --- a/src/party_menu_specials.c +++ b/src/party_menu_specials.c @@ -47,7 +47,7 @@ void SelectMoveDeleterMove(void) { ShowSelectMovePokemonSummaryScreen(gPlayerParty, gSpecialVar_0x8004, gPlayerPartyCount - 1, CB2_ReturnToField, 0); sub_8138B38(3); - gFieldCallback = FieldCallback_ReturnToEventScript2; + gFieldCallback = FieldCB_ContinueScriptHandleMusic; } void GetNumMovesSelectedMonHas(void) diff --git a/src/pokemon_jump_2.c b/src/pokemon_jump_2.c index aa1238e3f..9f2f9e404 100644 --- a/src/pokemon_jump_2.c +++ b/src/pokemon_jump_2.c @@ -1883,7 +1883,7 @@ static int sub_81497A8(void) static bool32 sub_8149804(void) { - return !Rfu.unk_124.count && !Rfu.unk_9e8.count; + return !Rfu.unk_124.count && !Rfu.sendQueue.count; } static int sub_8149834(u8 *arg0) diff --git a/src/post_battle_event_funcs.c b/src/post_battle_event_funcs.c index 86406fa2a..7d154f815 100644 --- a/src/post_battle_event_funcs.c +++ b/src/post_battle_event_funcs.c @@ -28,8 +28,8 @@ bool8 EnterHallOfFame(void) { SetGameStat(GAME_STAT_FIRST_HOF_PLAY_TIME, (gSaveBlock2Ptr->playTimeHours << 16) | (gSaveBlock2Ptr->playTimeMinutes << 8) | gSaveBlock2Ptr->playTimeSeconds); } - sub_804C1AC(); - sub_8055738(SPAWN_PALLET_TOWN); + SetContinueGameWarpStatus(); + SetContinueGameWarpToHealLocation(SPAWN_PALLET_TOWN); gaveAtLeastOneRibbon = FALSE; for (i = 0, r7 = &ribbonState; i < PARTY_SIZE; i++) { diff --git a/src/quest_log.c b/src/quest_log.c index 21a05f407..3c6b88d3d 100644 --- a/src/quest_log.c +++ b/src/quest_log.c @@ -96,7 +96,7 @@ struct UnkStruct_203B044 u8 gUnknown_3005E88; u16 sNumEventsInLogEntry; -struct UnkStruct_3005E90 gUnknown_3005E90; +struct FieldInput gUnknown_3005E90; struct QuestLogEntry * sCurQuestLogEntry; static struct UnkStruct_300201C * sFlagOrVarRecords; @@ -600,7 +600,7 @@ bool8 sub_8111000(void) { LoadPalette(stdpal_get(4), 0xF0, 0x20); SetQuestLogState(QL_STATE_2); - FieldCB_UnionRoomWarp(); + FieldCB_DefaultWarpExit(); gUnknown_203AE94 = (struct UnkStruct_203AE94){}; gUnknown_203AE94.unk_0_0 = 2; return 1; @@ -610,7 +610,7 @@ bool8 sub_8111038(void) { LoadPalette(stdpal_get(4), 0xF0, 0x20); SetQuestLogState(QL_STATE_2); - sub_807DF7C(); + FieldCB_WarpExitFadeFromBlack(); gUnknown_203AE94 = (struct UnkStruct_203AE94){}; gUnknown_203AE94.unk_0_0 = 2; return 1; @@ -1217,7 +1217,7 @@ static bool8 sub_8111F60(void) { LoadPalette(stdpal_get(4), 0xF0, 0x20); DrawPreviouslyOnQuestHeader(0); - sub_807DF7C(); + FieldCB_WarpExitFadeFromBlack(); CreateTask(sub_8111F8C, 0xFF); return TRUE; } @@ -1313,7 +1313,7 @@ static void Task_EndQuestLog(u8 taskId) break; default: if (gUnknown_203AE94.unk_0_6 == 1) - CreateMapNamePopupIfNotAlreadyRunning(1); + ShowMapNamePopup(1); CpuCopy16(gUnknown_203AE90, gPlttBufferUnfaded, 0x400); Free(gUnknown_203AE90); gUnknown_203AE94 = (struct UnkStruct_203AE94){}; @@ -1536,7 +1536,7 @@ void sub_811278C(u8 movementActionId, u8 duration) } } -void sub_81127F8(struct UnkStruct_3005E90 * a0) +void sub_81127F8(struct FieldInput * a0) { if (sQuestLogCursor < sNumEventsInLogEntry) { @@ -1616,7 +1616,7 @@ static void SetUpQuestLogEntry(u8 kind, struct QuestLogEntry *entry, u16 size) } sQuestLogCursor = 0; gUnknown_203B01C = 0; - gUnknown_3005E90 = (struct UnkStruct_3005E90){}; + gUnknown_3005E90 = (struct FieldInput){}; sNextStepDelay = sCurQuestLogEntry[sQuestLogCursor].unk_4; sMovementScripts[0][0] = sCurQuestLogEntry[sQuestLogCursor].unk_3; sMovementScripts[0][1] = 0xFF; diff --git a/src/region_map.c b/src/region_map.c index 3a902ec0e..f97d67ffc 100644 --- a/src/region_map.c +++ b/src/region_map.c @@ -3471,7 +3471,7 @@ static void GetPlayerPositionOnRegionMap(void) const struct MapHeader * mapHeader; struct WarpData * warp; - switch (get_map_light_level_by_bank_and_number(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)) + switch (GetMapTypeByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)) { default: case 1: @@ -3495,12 +3495,12 @@ static void GetPlayerPositionOnRegionMap(void) y = gSaveBlock1Ptr->escapeWarp.y; break; case 9: - mapHeader = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->warp2.mapGroup, gSaveBlock1Ptr->warp2.mapNum); + mapHeader = Overworld_GetMapHeaderByGroupAndId(gSaveBlock1Ptr->dynamicWarp.mapGroup, gSaveBlock1Ptr->dynamicWarp.mapNum); gUnknown_20399E4->field_014 = mapHeader->regionMapSectionId; width = mapHeader->mapLayout->width; height = mapHeader->mapLayout->height; - x = gSaveBlock1Ptr->warp2.x; - y = gSaveBlock1Ptr->warp2.y; + x = gSaveBlock1Ptr->dynamicWarp.x; + y = gSaveBlock1Ptr->dynamicWarp.y; break; case 8: if ((gUnknown_20399E4->field_014 = gMapHeader.regionMapSectionId) != MAPSEC_SPECIAL_AREA) @@ -3510,7 +3510,7 @@ static void GetPlayerPositionOnRegionMap(void) } else { - warp = &gSaveBlock1Ptr->warp2; + warp = &gSaveBlock1Ptr->dynamicWarp; mapHeader = Overworld_GetMapHeaderByGroupAndId(warp->mapGroup, warp->mapNum); gUnknown_20399E4->field_014 = mapHeader->regionMapSectionId; } @@ -4318,7 +4318,7 @@ static void sub_80C4F08(u8 taskId) case 4: if ((sub_80C3AC8(0) == 2 || sub_80C3AC8(0) == 4) && GetRegionMapPermission(MAPPERM_3) == TRUE) { - switch (get_map_light_level_by_bank_and_number(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)) + switch (GetMapTypeByGroupAndId(gSaveBlock1Ptr->location.mapGroup, gSaveBlock1Ptr->location.mapNum)) { case 4: case 8: @@ -4388,7 +4388,7 @@ static void sub_80C527C(u16 mapsec) u16 idx = mapsec - MAPSECS_KANTO; if (sMapsecToSpawn[idx][2]) { - sub_805546C(sMapsecToSpawn[idx][2]); + SetWarpDestinationToHealLocation(sMapsecToSpawn[idx][2]); SetUsedFlyQuestLogEvent(sMapsecToSpawn[idx]); } else diff --git a/src/scrcmd.c b/src/scrcmd.c index af977fbc7..bec0f4942 100644 --- a/src/scrcmd.c +++ b/src/scrcmd.c @@ -1168,7 +1168,7 @@ bool8 ScrCmd_setobjectmovementtype(struct ScriptContext * ctx) u16 localId = VarGet(ScriptReadHalfword(ctx)); u8 movementType = ScriptReadByte(ctx); - Overworld_SetMapObjTemplateMovementType(localId, movementType); + Overworld_SetObjEventTemplateMovementType(localId, movementType); return FALSE; } diff --git a/src/script.c b/src/script.c index ff74b40bc..13c571bac 100644 --- a/src/script.c +++ b/src/script.c @@ -358,7 +358,7 @@ void ScriptContext2_RunNewScript(const u8 *ptr) u8 *mapheader_get_tagged_pointer(u8 tag) { - u8 *mapScripts = gMapHeader.mapScripts; + const u8 *mapScripts = gMapHeader.mapScripts; if (mapScripts == NULL) return NULL; @@ -370,7 +370,7 @@ u8 *mapheader_get_tagged_pointer(u8 tag) if (*mapScripts == tag) { mapScripts++; - return (u8 *)(mapScripts[0] + (mapScripts[1] << 8) + (mapScripts[2] << 16) + (mapScripts[3] << 24)); + return T2_READ_PTR(mapScripts); } mapScripts += 5; } @@ -379,7 +379,7 @@ u8 *mapheader_get_tagged_pointer(u8 tag) void mapheader_run_script_by_tag(u8 tag) { u8 *ptr = mapheader_get_tagged_pointer(tag); - if (ptr) + if (ptr != NULL) ScriptContext2_RunNewScript(ptr); } @@ -387,7 +387,7 @@ u8 *mapheader_get_first_match_from_tagged_ptr_list(u8 tag) { u8 *ptr = mapheader_get_tagged_pointer(tag); - if (!ptr) + if (ptr == NULL) return NULL; while (1) @@ -411,22 +411,22 @@ void RunOnLoadMapScript(void) mapheader_run_script_by_tag(1); } -void mapheader_run_script_with_tag_x3(void) +void RunOnTransitionMapScript(void) { mapheader_run_script_by_tag(3); } -void mapheader_run_script_with_tag_x5(void) +void RunOnResumeMapScript(void) { mapheader_run_script_by_tag(5); } -void mapheader_run_script_with_tag_x7(void) +void RunOnReturnToFieldMapScript(void) { mapheader_run_script_by_tag(7); } -void mapheader_run_script_with_tag_x6(void) +void RunOnDiveWarpMapScript(void) { mapheader_run_script_by_tag(6); } @@ -447,7 +447,7 @@ bool8 TryRunOnFrameMapScript(void) return 1; } -void mapheader_run_first_tag4_script_list_match(void) +void TryRunOnWarpIntoMapScript(void) { u8 *ptr = mapheader_get_first_match_from_tagged_ptr_list(4); if (ptr) diff --git a/src/seagallop.c b/src/seagallop.c index fb55e6bd2..f7405296f 100644 --- a/src/seagallop.c +++ b/src/seagallop.c @@ -322,7 +322,7 @@ static void Task_Seagallop_3(void) SetWarpDestination(warpInfo[0], warpInfo[1], -1, warpInfo[2], warpInfo[3]); PlayRainStoppingSoundEffect(); PlaySE(SE_KAIDAN); - gFieldCallback = FieldCB_UnionRoomWarp; + gFieldCallback = FieldCB_DefaultWarpExit; WarpIntoMap(); SetMainCallback2(CB2_LoadMap); ResetInitialPlayerAvatarState(); diff --git a/src/strings.c b/src/strings.c index 547a36138..fbe51254c 100644 --- a/src/strings.c +++ b/src/strings.c @@ -958,8 +958,8 @@ const u8 gText_Sorry[] = _("SORRY"); const u8 gText_YaySmileEmoji[] = _("YAY{EXTRA 0xF9}"); const u8 gText_ThankYou[] = _("THANK YOU"); const u8 gText_ByeBye[] = _("BYE-BYE!"); -const u8 gUnknown_841B554[] = _("{PLAYER} scurried to a POKéMON CENTER,\nprotecting the exhausted and fainted\nPOKéMON from further harm‥\p"); -const u8 gUnknown_841B5B6[] = _("{PLAYER} scurried back home, protecting\nthe exhausted and fainted POKéMON from\nfurther harm‥\p"); +const u8 gText_PlayerScurriedToCenter[] = _("{PLAYER} scurried to a POKéMON CENTER,\nprotecting the exhausted and fainted\nPOKéMON from further harm‥\p"); +const u8 gText_PlayerScurriedBackHome[] = _("{PLAYER} scurried back home, protecting\nthe exhausted and fainted POKéMON from\nfurther harm‥\p"); const u8 gUnknown_841B60E[] = _("PLAYER: {DYNAMIC 0x00}"); const u8 gUnknown_841B619[] = _("This document is issued in\nrecognition of your magnificent\nachievement - the completion of\nthe {DYNAMIC 0x01} POKéDEX."); const u8 gUnknown_841B684[] = _("GAME FREAK"); diff --git a/src/trade.c b/src/trade.c index bd6860e85..bb2634613 100644 --- a/src/trade.c +++ b/src/trade.c @@ -2022,7 +2022,7 @@ static void sub_804E944(void) Free(sTradeMenuResourcesPtr); FreeAllWindowBuffers(); DestroyWirelessStatusIndicatorSprite(); - SetMainCallback2(c2_8056854); + SetMainCallback2(CB2_ReturnToFieldFromMultiplayer); } } else @@ -2032,7 +2032,7 @@ static void sub_804E944(void) Free(sSpriteTextTileBuffer); Free(sTradeMenuResourcesPtr); FreeAllWindowBuffers(); - SetMainCallback2(c2_8056854); + SetMainCallback2(CB2_ReturnToFieldFromMultiplayer); } } } diff --git a/src/trade_scene.c b/src/trade_scene.c index d609a9b53..308cd6e5b 100644 --- a/src/trade_scene.c +++ b/src/trade_scene.c @@ -2747,7 +2747,7 @@ static void Task_WaitFadeAndStartInGameTradeAnim(u8 taskId) if (!gPaletteFade.active) { SetMainCallback2(CB2_InitTradeAnim_InGameTrade); - gFieldCallback = FieldCallback_ReturnToEventScript2; + gFieldCallback = FieldCB_ContinueScriptHandleMusic; DestroyTask(taskId); } } diff --git a/src/vs_seeker.c b/src/vs_seeker.c index 599e4f9b4..7054a13ed 100644 --- a/src/vs_seeker.c +++ b/src/vs_seeker.c @@ -681,7 +681,7 @@ bool8 sub_810C4EC(void) return FALSE; } -void sub_810C578(void) +void TryUpdateRandomTrainerRematches(u16 mapGroup, u16 mapNum) { FlagClear(FLAG_SYS_VS_SEEKER_CHARGING); sub_810C640(); |