diff options
Diffstat (limited to 'src/event_object_movement.c')
| -rw-r--r-- | src/event_object_movement.c | 2944 |
1 files changed, 1471 insertions, 1473 deletions
diff --git a/src/event_object_movement.c b/src/event_object_movement.c index 84900e48e..d23bba92b 100644 --- a/src/event_object_movement.c +++ b/src/event_object_movement.c @@ -21,7 +21,7 @@ #include "sprite.h" #include "trainer_see.h" #include "util.h" -#include "constants/map_objects.h" +#include "constants/event_objects.h" // this file was known as evobjmv.c in Game Freak's original source @@ -29,35 +29,33 @@ extern u8 gUnknown_020375B4; extern u16 gUnknown_020375B6; extern u8 *gUnknown_020375B8; -// Static ROM declarations - static void sub_808D450(void); -static u8 GetFieldObjectIdByLocalId(u8); -static u8 GetFieldObjectIdByLocalIdAndMapInternal(u8, u8, u8); -static bool8 GetAvailableFieldObjectSlot(u16, u8, u8, u8 *); -static void FieldObjectHandleDynamicGraphicsId(struct MapObject *); -static void RemoveFieldObjectInternal (struct MapObject *); -static u16 GetFieldObjectFlagIdByFieldObjectId(u8); -static void sub_8096518(struct MapObject *, struct Sprite *); -static void MakeObjectTemplateFromFieldObjectTemplate(struct MapObjectTemplate *, struct SpriteTemplate *, const struct SubspriteTable **); -static void GetFieldObjectMovingCameraOffset(s16 *, s16 *); -static struct MapObjectTemplate *GetFieldObjectTemplateByLocalIdAndMap(u8, u8, u8); +static u8 GetEventObjectIdByLocalId(u8); +static u8 GetEventObjectIdByLocalIdAndMapInternal(u8, u8, u8); +static bool8 GetAvailableEventObjectSlot(u16, u8, u8, u8 *); +static void EventObjectHandleDynamicGraphicsId(struct EventObject *); +static void RemoveEventObjectInternal (struct EventObject *); +static u16 GetEventObjectFlagIdByEventObjectId(u8); +static void sub_8096518(struct EventObject *, struct Sprite *); +static void MakeObjectTemplateFromEventObjectTemplate(struct EventObjectTemplate *, struct SpriteTemplate *, const struct SubspriteTable **); +static void GetEventObjectMovingCameraOffset(s16 *, s16 *); +static struct EventObjectTemplate *GetEventObjectTemplateByLocalIdAndMap(u8, u8, u8); static void sub_808E894(u16); -static void RemoveFieldObjectIfOutsideView(struct MapObject *); +static void RemoveEventObjectIfOutsideView(struct EventObject *); static void sub_808E1B8(u8, s16, s16); -static void SetPlayerAvatarFieldObjectIdAndObjectId(u8, u8); -static void sub_808E38C(struct MapObject *); +static void SetPlayerAvatarEventObjectIdAndObjectId(u8, u8); +static void sub_808E38C(struct EventObject *); static u8 sub_808E8F4(const struct SpritePalette *); -static u8 FindFieldObjectPaletteIndexByTag(u16); +static u8 FindEventObjectPaletteIndexByTag(u16); static void sub_808EAB0(u16, u8); -static bool8 FieldObjectDoesZCoordMatch(struct MapObject *, u8); +static bool8 EventObjectDoesZCoordMatch(struct EventObject *, u8); static void ObjectCB_CameraObject(struct Sprite *); static void CameraObject_0(struct Sprite *); static void CameraObject_1(struct Sprite *); static void CameraObject_2(struct Sprite *); -static struct MapObjectTemplate *FindFieldObjectTemplateInArrayByLocalId(u8 localId, struct MapObjectTemplate *templates, u8 count); -static void npc_reset(struct MapObject *, struct Sprite *); -static void FieldObjectSetRegularAnim(struct MapObject *, struct Sprite *, u8); +static struct EventObjectTemplate *FindEventObjectTemplateInArrayByLocalId(u8 localId, struct EventObjectTemplate *templates, u8 count); +static void npc_reset(struct EventObject *, struct Sprite *); +static void EventObjectSetRegularAnim(struct EventObject *, struct Sprite *, u8); u8 sub_8093438(u32); u8 sub_80934BC(u32); @@ -65,48 +63,48 @@ u8 sub_8093514(u32); u8 GetJumpLedgeAnimId(u32); void sub_8092F88(u32, s16 *, s16 *, s16, s16); -bool8 FieldObjectExecRegularAnim(struct MapObject *, struct Sprite *); -static void SetFieldObjectStepTimer(struct Sprite *, s16); -bool8 RunFieldObjectStepTimer(struct Sprite *); -bool8 npc_block_way__next_tile(struct MapObject *, u8); +bool8 EventObjectExecRegularAnim(struct EventObject *, struct Sprite *); +static void SetEventObjectStepTimer(struct Sprite *, s16); +bool8 RunEventObjectStepTimer(struct Sprite *); +bool8 npc_block_way__next_tile(struct EventObject *, u8); static u32 state_to_direction(u8, u32, u32); -/*static*/ void sub_80964E8(struct MapObject *, struct Sprite *); -static void FieldObjectExecSpecialAnim(struct MapObject *, struct Sprite *); -/*static*/ void npc_obj_transfer_image_anim_pause_flag(struct MapObject *, struct Sprite *); - -static bool8 IsCoordOutsideFieldObjectMovementRect(struct MapObject *, s16, s16); -static bool8 IsMetatileDirectionallyImpassable(struct MapObject *, s16, s16, u8); -static bool8 CheckForCollisionBetweenFieldObjects(struct MapObject *, s16, s16); -bool8 sub_809558C(struct MapObject *, struct Sprite *); -bool8 sub_8095B64(struct MapObject *, struct Sprite *); -static void sub_8096530(struct MapObject *, struct Sprite *); -static void npc_update_obj_anim_flag(struct MapObject *, struct Sprite *); -static void FieldObjectUpdateMetatileBehaviors(struct MapObject*); -static void GetGroundEffectFlags_Reflection(struct MapObject*, u32*); -static void GetGroundEffectFlags_TallGrassOnSpawn(struct MapObject*, u32*); -static void GetGroundEffectFlags_LongGrassOnSpawn(struct MapObject*, u32*); -static void GetGroundEffectFlags_SandHeap(struct MapObject*, u32*); -static void GetGroundEffectFlags_ShallowFlowingWater(struct MapObject*, u32*); -static void GetGroundEffectFlags_ShortGrass(struct MapObject*, u32*); -static void GetGroundEffectFlags_HotSprings(struct MapObject*, u32*); -static void GetGroundEffectFlags_TallGrassOnBeginStep(struct MapObject*, u32*); -static void GetGroundEffectFlags_LongGrassOnBeginStep(struct MapObject*, u32*); -static void GetGroundEffectFlags_Tracks(struct MapObject*, u32*); -static void GetGroundEffectFlags_Puddle(struct MapObject*, u32*); -static void GetGroundEffectFlags_Ripple(struct MapObject*, u32*); -static void GetGroundEffectFlags_Seaweed(struct MapObject*, u32*); -static void GetGroundEffectFlags_JumpLanding(struct MapObject*, u32*); -static u8 FieldObjectCheckForReflectiveSurface(struct MapObject*); +/*static*/ void sub_80964E8(struct EventObject *, struct Sprite *); +static void EventObjectExecSpecialAnim(struct EventObject *, struct Sprite *); +/*static*/ void npc_obj_transfer_image_anim_pause_flag(struct EventObject *, struct Sprite *); + +static bool8 IsCoordOutsideEventObjectMovementRect(struct EventObject *, s16, s16); +static bool8 IsMetatileDirectionallyImpassable(struct EventObject *, s16, s16, u8); +static bool8 CheckForCollisionBetweenEventObjects(struct EventObject *, s16, s16); +bool8 sub_809558C(struct EventObject *, struct Sprite *); +bool8 sub_8095B64(struct EventObject *, struct Sprite *); +static void sub_8096530(struct EventObject *, struct Sprite *); +static void npc_update_obj_anim_flag(struct EventObject *, struct Sprite *); +static void EventObjectUpdateMetatileBehaviors(struct EventObject*); +static void GetGroundEffectFlags_Reflection(struct EventObject*, u32*); +static void GetGroundEffectFlags_TallGrassOnSpawn(struct EventObject*, u32*); +static void GetGroundEffectFlags_LongGrassOnSpawn(struct EventObject*, u32*); +static void GetGroundEffectFlags_SandHeap(struct EventObject*, u32*); +static void GetGroundEffectFlags_ShallowFlowingWater(struct EventObject*, u32*); +static void GetGroundEffectFlags_ShortGrass(struct EventObject*, u32*); +static void GetGroundEffectFlags_HotSprings(struct EventObject*, u32*); +static void GetGroundEffectFlags_TallGrassOnBeginStep(struct EventObject*, u32*); +static void GetGroundEffectFlags_LongGrassOnBeginStep(struct EventObject*, u32*); +static void GetGroundEffectFlags_Tracks(struct EventObject*, u32*); +static void GetGroundEffectFlags_Puddle(struct EventObject*, u32*); +static void GetGroundEffectFlags_Ripple(struct EventObject*, u32*); +static void GetGroundEffectFlags_Seaweed(struct EventObject*, u32*); +static void GetGroundEffectFlags_JumpLanding(struct EventObject*, u32*); +static u8 EventObjectCheckForReflectiveSurface(struct EventObject*); static u8 GetReflectionTypeByMetatileBehavior(u32); static void InitObjectPriorityByZCoord(struct Sprite *sprite, u8 z); -static void FieldObjectUpdateSubpriority(struct MapObject*, struct Sprite*); -static void DoTracksGroundEffect_None(struct MapObject*, struct Sprite*, u8); -static void DoTracksGroundEffect_Footprints(struct MapObject*, struct Sprite*, u8); -static void DoTracksGroundEffect_BikeTireTracks(struct MapObject*, struct Sprite*, u8); -static void DoRippleFieldEffect(struct MapObject*, struct Sprite*); -static void DoGroundEffects_OnSpawn(struct MapObject*, struct Sprite*); -static void DoGroundEffects_OnBeginStep(struct MapObject*, struct Sprite*); -static void DoGroundEffects_OnFinishStep(struct MapObject*, struct Sprite*); +static void EventObjectUpdateSubpriority(struct EventObject*, struct Sprite*); +static void DoTracksGroundEffect_None(struct EventObject*, struct Sprite*, u8); +static void DoTracksGroundEffect_Footprints(struct EventObject*, struct Sprite*, u8); +static void DoTracksGroundEffect_BikeTireTracks(struct EventObject*, struct Sprite*, u8); +static void DoRippleFieldEffect(struct EventObject*, struct Sprite*); +static void DoGroundEffects_OnSpawn(struct EventObject*, struct Sprite*); +static void DoGroundEffects_OnBeginStep(struct EventObject*, struct Sprite*); +static void DoGroundEffects_OnFinishStep(struct EventObject*, struct Sprite*); static void sub_8097D68(struct Sprite*); static void sub_8097FE4(u8); @@ -125,87 +123,87 @@ void (*const gCameraObjectFuncs[])(struct Sprite *) = { // movement type callbacks void (*const gUnknown_08505438[])(struct Sprite *) = { - FieldObjectCB_NoMovement1, - FieldObjectCB_LookRandomDirections, - FieldObjectCB_GoRandomDirections, - FieldObjectCB_RandomlyGoNorthOrSouth, - FieldObjectCB_RandomlyGoNorthOrSouth, - FieldObjectCB_RandomlyGoEastOrWest, - FieldObjectCB_RandomlyGoEastOrWest, - FieldObjectCB_FaceFixedDirection, - FieldObjectCB_FaceFixedDirection, - FieldObjectCB_FaceFixedDirection, - FieldObjectCB_FaceFixedDirection, - FieldObjectCB_NoMovement2, - FieldObjectCB_BerryTree, - FieldObjectCB_RandomlyLookNorthOrSouth, - FieldObjectCB_RandomlyLookEastOrWest, - FieldObjectCB_RandomlyLookNorthOrWest, - FieldObjectCB_RandomlyLookNorthOrEast, - FieldObjectCB_RandomlyLookSouthOrWest, - FieldObjectCB_RandomlyLookSouthOrEast, - FieldObjectCB_RandomlyLookNorthOrSouthOrWest, - FieldObjectCB_RandomlyLookNorthOrSouthOrEast, - FieldObjectCB_RandomlyLookNorthOrEastOrWest, - FieldObjectCB_RandomlyLookSouthOrEastOrWest, - FieldObjectCB_LookAroundCounterclockwise, - FieldObjectCB_LookAroundClockwise, - FieldObjectCB_AlternatelyGoInOppositeDirections, - FieldObjectCB_AlternatelyGoInOppositeDirections, - FieldObjectCB_AlternatelyGoInOppositeDirections, - FieldObjectCB_AlternatelyGoInOppositeDirections, - FieldObjectCB_GoInDirectionSequence1, - FieldObjectCB_GoInDirectionSequence2, - FieldObjectCB_GoInDirectionSequence3, - FieldObjectCB_GoInDirectionSequence4, - FieldObjectCB_GoInDirectionSequence5, - FieldObjectCB_GoInDirectionSequence6, - FieldObjectCB_GoInDirectionSequence7, - FieldObjectCB_GoInDirectionSequence8, - FieldObjectCB_GoInDirectionSequence9, - FieldObjectCB_GoInDirectionSequence10, - FieldObjectCB_GoInDirectionSequence11, - FieldObjectCB_GoInDirectionSequence12, - FieldObjectCB_GoInDirectionSequence13, - FieldObjectCB_GoInDirectionSequence14, - FieldObjectCB_GoInDirectionSequence15, - FieldObjectCB_GoInDirectionSequence16, - FieldObjectCB_GoInDirectionSequence17, - FieldObjectCB_GoInDirectionSequence18, - FieldObjectCB_GoInDirectionSequence19, - FieldObjectCB_GoInDirectionSequence20, - FieldObjectCB_GoInDirectionSequence21, - FieldObjectCB_GoInDirectionSequence22, - FieldObjectCB_GoInDirectionSequence23, - FieldObjectCB_GoInDirectionSequence24, - FieldObjectCB_CopyPlayer1, - FieldObjectCB_CopyPlayer1, - FieldObjectCB_CopyPlayer1, - FieldObjectCB_CopyPlayer1, - FieldObjectCB_TreeDisguise, - FieldObjectCB_MountainDisguise, - FieldObjectCB_CopyPlayer2, - FieldObjectCB_CopyPlayer2, - FieldObjectCB_CopyPlayer2, - FieldObjectCB_CopyPlayer2, - FieldObjectCB_Hidden1, - FieldObjectCB_WalkInPlace1, - FieldObjectCB_WalkInPlace1, - FieldObjectCB_WalkInPlace1, - FieldObjectCB_WalkInPlace1, - FieldObjectCB_WalkInPlace2, - FieldObjectCB_WalkInPlace2, - FieldObjectCB_WalkInPlace2, - FieldObjectCB_WalkInPlace2, - FieldObjectCB_WalkInPlace3, - FieldObjectCB_WalkInPlace3, - FieldObjectCB_WalkInPlace3, - FieldObjectCB_WalkInPlace3, - FieldObjectCB_Hidden2, - FieldObjectCB_WalkInPlace4, - FieldObjectCB_WalkInPlace4, - FieldObjectCB_WalkInPlace4, - FieldObjectCB_WalkInPlace4, + EventObjectCB_NoMovement1, + EventObjectCB_LookRandomDirections, + EventObjectCB_GoRandomDirections, + EventObjectCB_RandomlyGoNorthOrSouth, + EventObjectCB_RandomlyGoNorthOrSouth, + EventObjectCB_RandomlyGoEastOrWest, + EventObjectCB_RandomlyGoEastOrWest, + EventObjectCB_FaceFixedDirection, + EventObjectCB_FaceFixedDirection, + EventObjectCB_FaceFixedDirection, + EventObjectCB_FaceFixedDirection, + EventObjectCB_NoMovement2, + EventObjectCB_BerryTree, + EventObjectCB_RandomlyLookNorthOrSouth, + EventObjectCB_RandomlyLookEastOrWest, + EventObjectCB_RandomlyLookNorthOrWest, + EventObjectCB_RandomlyLookNorthOrEast, + EventObjectCB_RandomlyLookSouthOrWest, + EventObjectCB_RandomlyLookSouthOrEast, + EventObjectCB_RandomlyLookNorthOrSouthOrWest, + EventObjectCB_RandomlyLookNorthOrSouthOrEast, + EventObjectCB_RandomlyLookNorthOrEastOrWest, + EventObjectCB_RandomlyLookSouthOrEastOrWest, + EventObjectCB_LookAroundCounterclockwise, + EventObjectCB_LookAroundClockwise, + EventObjectCB_AlternatelyGoInOppositeDirections, + EventObjectCB_AlternatelyGoInOppositeDirections, + EventObjectCB_AlternatelyGoInOppositeDirections, + EventObjectCB_AlternatelyGoInOppositeDirections, + EventObjectCB_GoInDirectionSequence1, + EventObjectCB_GoInDirectionSequence2, + EventObjectCB_GoInDirectionSequence3, + EventObjectCB_GoInDirectionSequence4, + EventObjectCB_GoInDirectionSequence5, + EventObjectCB_GoInDirectionSequence6, + EventObjectCB_GoInDirectionSequence7, + EventObjectCB_GoInDirectionSequence8, + EventObjectCB_GoInDirectionSequence9, + EventObjectCB_GoInDirectionSequence10, + EventObjectCB_GoInDirectionSequence11, + EventObjectCB_GoInDirectionSequence12, + EventObjectCB_GoInDirectionSequence13, + EventObjectCB_GoInDirectionSequence14, + EventObjectCB_GoInDirectionSequence15, + EventObjectCB_GoInDirectionSequence16, + EventObjectCB_GoInDirectionSequence17, + EventObjectCB_GoInDirectionSequence18, + EventObjectCB_GoInDirectionSequence19, + EventObjectCB_GoInDirectionSequence20, + EventObjectCB_GoInDirectionSequence21, + EventObjectCB_GoInDirectionSequence22, + EventObjectCB_GoInDirectionSequence23, + EventObjectCB_GoInDirectionSequence24, + EventObjectCB_CopyPlayer1, + EventObjectCB_CopyPlayer1, + EventObjectCB_CopyPlayer1, + EventObjectCB_CopyPlayer1, + EventObjectCB_TreeDisguise, + EventObjectCB_MountainDisguise, + EventObjectCB_CopyPlayer2, + EventObjectCB_CopyPlayer2, + EventObjectCB_CopyPlayer2, + EventObjectCB_CopyPlayer2, + EventObjectCB_Hidden1, + EventObjectCB_WalkInPlace1, + EventObjectCB_WalkInPlace1, + EventObjectCB_WalkInPlace1, + EventObjectCB_WalkInPlace1, + EventObjectCB_WalkInPlace2, + EventObjectCB_WalkInPlace2, + EventObjectCB_WalkInPlace2, + EventObjectCB_WalkInPlace2, + EventObjectCB_WalkInPlace3, + EventObjectCB_WalkInPlace3, + EventObjectCB_WalkInPlace3, + EventObjectCB_WalkInPlace3, + EventObjectCB_Hidden2, + EventObjectCB_WalkInPlace4, + EventObjectCB_WalkInPlace4, + EventObjectCB_WalkInPlace4, + EventObjectCB_WalkInPlace4, }; const u8 gRangedMovementTypes[] = { @@ -385,41 +383,41 @@ const u8 gInitialMovementTypeFacingDirections[] = { #include "data/field_event_obj/event_object_graphics_info.h" const struct SpritePalette gUnknown_0850BBC8[] = { - {gFieldObjectPalette0, 0x1103}, - {gFieldObjectPalette1, 0x1104}, - {gFieldObjectPalette2, 0x1105}, - {gFieldObjectPalette3, 0x1106}, - {gFieldObjectPalette4, 0x1107}, - {gFieldObjectPalette5, 0x1108}, - {gFieldObjectPalette6, 0x1109}, - {gFieldObjectPalette7, 0x110A}, - {gFieldObjectPalette8, 0x1100}, - {gFieldObjectPalette9, 0x1101}, - {gFieldObjectPalette10, 0x1102}, - {gFieldObjectPalette11, 0x1115}, - {gFieldObjectPalette12, 0x110B}, - {gFieldObjectPalette13, 0x110C}, - {gFieldObjectPalette14, 0x110D}, - {gFieldObjectPalette15, 0x110E}, - {gFieldObjectPalette16, 0x110F}, - {gFieldObjectPalette17, 0x1110}, - {gFieldObjectPalette18, 0x1111}, - {gFieldObjectPalette19, 0x1112}, - {gFieldObjectPalette20, 0x1113}, - {gFieldObjectPalette21, 0x1114}, - {gFieldObjectPalette22, 0x1116}, - {gFieldObjectPalette23, 0x1117}, - {gFieldObjectPalette24, 0x1118}, - {gFieldObjectPalette25, 0x1119}, - {gFieldObjectPalette26, 0x111B}, - {gFieldObjectPalette27, 0x111C}, - {gFieldObjectPalette28, 0x111D}, - {gFieldObjectPalette29, 0x111E}, - {gFieldObjectPalette30, 0x111F}, - {gFieldObjectPalette31, 0x1120}, - {gFieldObjectPalette32, 0x1121}, - {gFieldObjectPalette33, 0x1122}, - {gFieldObjectPalette34, 0x1123}, + {gEventObjectPalette0, 0x1103}, + {gEventObjectPalette1, 0x1104}, + {gEventObjectPalette2, 0x1105}, + {gEventObjectPalette3, 0x1106}, + {gEventObjectPalette4, 0x1107}, + {gEventObjectPalette5, 0x1108}, + {gEventObjectPalette6, 0x1109}, + {gEventObjectPalette7, 0x110A}, + {gEventObjectPalette8, 0x1100}, + {gEventObjectPalette9, 0x1101}, + {gEventObjectPalette10, 0x1102}, + {gEventObjectPalette11, 0x1115}, + {gEventObjectPalette12, 0x110B}, + {gEventObjectPalette13, 0x110C}, + {gEventObjectPalette14, 0x110D}, + {gEventObjectPalette15, 0x110E}, + {gEventObjectPalette16, 0x110F}, + {gEventObjectPalette17, 0x1110}, + {gEventObjectPalette18, 0x1111}, + {gEventObjectPalette19, 0x1112}, + {gEventObjectPalette20, 0x1113}, + {gEventObjectPalette21, 0x1114}, + {gEventObjectPalette22, 0x1116}, + {gEventObjectPalette23, 0x1117}, + {gEventObjectPalette24, 0x1118}, + {gEventObjectPalette25, 0x1119}, + {gEventObjectPalette26, 0x111B}, + {gEventObjectPalette27, 0x111C}, + {gEventObjectPalette28, 0x111D}, + {gEventObjectPalette29, 0x111E}, + {gEventObjectPalette30, 0x111F}, + {gEventObjectPalette31, 0x1120}, + {gEventObjectPalette32, 0x1121}, + {gEventObjectPalette33, 0x1122}, + {gEventObjectPalette34, 0x1123}, {NULL, 0x0000}, }; @@ -1077,28 +1075,28 @@ const u8 gUnknown_0850DC3F[][4] = { // Code -static void npc_clear_ids_and_state(struct MapObject *mapObject) +static void npc_clear_ids_and_state(struct EventObject *eventObject) { - *mapObject = (struct MapObject){}; - mapObject->localId = 0xFF; - mapObject->mapNum = -1; - mapObject->mapGroup = -1; - mapObject->movementActionId = -1; + *eventObject = (struct EventObject){}; + eventObject->localId = 0xFF; + eventObject->mapNum = -1; + eventObject->mapGroup = -1; + eventObject->movementActionId = -1; } static void npcs_clear_ids_and_state(void) { u8 i; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - npc_clear_ids_and_state(&gMapObjects[i]); + npc_clear_ids_and_state(&gEventObjects[i]); } } void sub_808D438(void) { - ZeroAllLinkPlayerMapObjects(); + ZeroAllLinkPlayerEventObjects(); npcs_clear_ids_and_state(); ClearPlayerAvatarInfo(); sub_808D450(); @@ -1125,9 +1123,9 @@ u8 sub_808D4F4(void) { u8 i; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (!gMapObjects[i].active) + if (!gEventObjects[i].active) { break; } @@ -1135,32 +1133,32 @@ u8 sub_808D4F4(void) return i; } -u8 GetFieldObjectIdByLocalIdAndMap(u8 localId, u8 mapId, u8 mapGroupId) +u8 GetEventObjectIdByLocalIdAndMap(u8 localId, u8 mapId, u8 mapGroupId) { if (localId < 0xff) { - return GetFieldObjectIdByLocalIdAndMapInternal(localId, mapId, mapGroupId); + return GetEventObjectIdByLocalIdAndMapInternal(localId, mapId, mapGroupId); } - return GetFieldObjectIdByLocalId(localId); + return GetEventObjectIdByLocalId(localId); } -bool8 TryGetFieldObjectIdByLocalIdAndMap(u8 localId, u8 mapId, u8 mapGroupId, u8 *fieldObjectId) +bool8 TryGetEventObjectIdByLocalIdAndMap(u8 localId, u8 mapId, u8 mapGroupId, u8 *eventObjectId) { - *fieldObjectId = GetFieldObjectIdByLocalIdAndMap(localId, mapId, mapGroupId); - if (*fieldObjectId == NUM_FIELD_OBJECTS) + *eventObjectId = GetEventObjectIdByLocalIdAndMap(localId, mapId, mapGroupId); + if (*eventObjectId == NUM_EVENT_OBJECTS) { return TRUE; } return FALSE; } -u8 GetFieldObjectIdByXY(s16 x, s16 y) +u8 GetEventObjectIdByXY(s16 x, s16 y) { u8 i; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (gMapObjects[i].active && gMapObjects[i].currentCoords.x == x && gMapObjects[i].currentCoords.y == y) + if (gEventObjects[i].active && gEventObjects[i].currentCoords.x == x && gEventObjects[i].currentCoords.y == y) { break; } @@ -1168,92 +1166,92 @@ u8 GetFieldObjectIdByXY(s16 x, s16 y) return i; } -static u8 GetFieldObjectIdByLocalIdAndMapInternal(u8 localId, u8 mapId, u8 mapGroupId) +static u8 GetEventObjectIdByLocalIdAndMapInternal(u8 localId, u8 mapId, u8 mapGroupId) { u8 i; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (gMapObjects[i].active && gMapObjects[i].localId == localId && gMapObjects[i].mapNum == mapId && gMapObjects[i].mapGroup == mapGroupId) + if (gEventObjects[i].active && gEventObjects[i].localId == localId && gEventObjects[i].mapNum == mapId && gEventObjects[i].mapGroup == mapGroupId) { return i; } } - return NUM_FIELD_OBJECTS; + return NUM_EVENT_OBJECTS; } -static u8 GetFieldObjectIdByLocalId(u8 localId) +static u8 GetEventObjectIdByLocalId(u8 localId) { u8 i; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (gMapObjects[i].active && gMapObjects[i].localId == localId) + if (gEventObjects[i].active && gEventObjects[i].localId == localId) { return i; } } - return NUM_FIELD_OBJECTS; + return NUM_EVENT_OBJECTS; } // This function has the same nonmatching quirk as in Ruby/Sapphire. #ifdef NONMATCHING -static u8 InitFieldObjectStateFromTemplate(struct MapObjectTemplate *template, u8 mapNum, u8 mapGroup) +static u8 InitEventObjectStateFromTemplate(struct EventObjectTemplate *template, u8 mapNum, u8 mapGroup) { - struct MapObject *mapObject; + struct EventObject *eventObject; s16 x; s16 y; u8 slot; // mapNum and mapGroup are in the wrong registers (r7/r6 instead of r6/r7) - if (GetAvailableFieldObjectSlot(template->localId, mapNum, mapGroup, &slot)) + if (GetAvailableEventObjectSlot(template->localId, mapNum, mapGroup, &slot)) { - return NUM_FIELD_OBJECTS; + return NUM_EVENT_OBJECTS; } - mapObject = &gMapObjects[slot]; - npc_clear_ids_and_state(mapObject); + eventObject = &gEventObjects[slot]; + npc_clear_ids_and_state(eventObject); x = template->x + 7; y = template->y + 7; - mapObject->active = TRUE; - mapObject->triggerGroundEffectsOnMove = TRUE; - mapObject->graphicsId = template->graphicsId; - mapObject->movementType = template->movementType; - mapObject->localId = template->localId; - mapObject->mapNum = mapNum; - mapObject->mapGroup = mapGroup; - mapObject->initialCoords.x = x; - mapObject->initialCoords.y = y; - mapObject->currentCoords.x = x; - mapObject->currentCoords.y = y; - mapObject->previousCoords.x = x; - mapObject->previousCoords.y = y; - mapObject->currentElevation = template->elevation; - mapObject->previousElevation = template->elevation; + eventObject->active = TRUE; + eventObject->triggerGroundEffectsOnMove = TRUE; + eventObject->graphicsId = template->graphicsId; + eventObject->movementType = template->movementType; + eventObject->localId = template->localId; + eventObject->mapNum = mapNum; + eventObject->mapGroup = mapGroup; + eventObject->initialCoords.x = x; + eventObject->initialCoords.y = y; + eventObject->currentCoords.x = x; + eventObject->currentCoords.y = y; + eventObject->previousCoords.x = x; + eventObject->previousCoords.y = y; + eventObject->currentElevation = template->elevation; + eventObject->previousElevation = template->elevation; // For some reason, 0x0F is placed in r9, to be used later - mapObject->range.as_nybbles.x = template->movementRangeX; - mapObject->range.as_nybbles.y = template->movementRangeY; - mapObject->trainerType = template->trainerType; - mapObject->trainerRange_berryTreeId = template->trainerRange_berryTreeId; - mapObject->previousMovementDirection = gInitialMovementTypeFacingDirections[template->movementType]; - FieldObjectSetDirection(mapObject, mapObject->previousMovementDirection); - FieldObjectHandleDynamicGraphicsId(mapObject); + eventObject->range.as_nybbles.x = template->movementRangeX; + eventObject->range.as_nybbles.y = template->movementRangeY; + eventObject->trainerType = template->trainerType; + eventObject->trainerRange_berryTreeId = template->trainerRange_berryTreeId; + eventObject->previousMovementDirection = gInitialMovementTypeFacingDirections[template->movementType]; + EventObjectSetDirection(eventObject, eventObject->previousMovementDirection); + EventObjectHandleDynamicGraphicsId(eventObject); - if (gRangedMovementTypes[mapObject->movementType]) + if (gRangedMovementTypes[eventObject->movementType]) { - if ((mapObject->range.as_nybbles.x) == 0) + if ((eventObject->range.as_nybbles.x) == 0) { // r9 is invoked here - mapObject->range.as_nybbles.x ++; + eventObject->range.as_nybbles.x ++; } - if ((mapObject->range.as_nybbles.y) == 0) + if ((eventObject->range.as_nybbles.y) == 0) { - mapObject->range.as_nybbles.y ++; + eventObject->range.as_nybbles.y ++; } } return slot; } #else -static NAKED u8 InitFieldObjectStateFromTemplate(struct MapObjectTemplate *template, u8 mapId, u8 mapGroupId) +static NAKED u8 InitEventObjectStateFromTemplate(struct EventObjectTemplate *template, u8 mapId, u8 mapGroupId) { asm_unified("\tpush {r4-r7,lr}\n" "\tmov r7, r9\n" @@ -1269,7 +1267,7 @@ static NAKED u8 InitFieldObjectStateFromTemplate(struct MapObjectTemplate *templ "\tadds r1, r6, 0\n" "\tadds r2, r7, 0\n" "\tmov r3, sp\n" - "\tbl GetAvailableFieldObjectSlot\n" + "\tbl GetAvailableEventObjectSlot\n" "\tlsls r0, 24\n" "\tcmp r0, 0\n" "\tbeq _0808D66E\n" @@ -1281,7 +1279,7 @@ static NAKED u8 InitFieldObjectStateFromTemplate(struct MapObjectTemplate *templ "\tlsls r0, r1, 3\n" "\tadds r0, r1\n" "\tlsls r0, 2\n" - "\tldr r1, =gMapObjects\n" + "\tldr r1, =gEventObjects\n" "\tadds r4, r0, r1\n" "\tadds r0, r4, 0\n" "\tbl npc_clear_ids_and_state\n" @@ -1358,9 +1356,9 @@ static NAKED u8 InitFieldObjectStateFromTemplate(struct MapObjectTemplate *templ "\tstrb r1, [r0]\n" "\tldrb r1, [r0]\n" "\tadds r0, r4, 0\n" - "\tbl FieldObjectSetDirection\n" + "\tbl EventObjectSetDirection\n" "\tadds r0, r4, 0\n" - "\tbl FieldObjectHandleDynamicGraphicsId\n" + "\tbl EventObjectHandleDynamicGraphicsId\n" "\tldr r1, =gRangedMovementTypes\n" "\tldrb r0, [r4, 0x6]\n" "\tadds r0, r1\n" @@ -1413,7 +1411,7 @@ u8 unref_sub_808D77C(u8 localId) { u8 i; u8 nObjects; - struct MapObjectTemplate *template; + struct EventObjectTemplate *template; if (gMapHeader.events != NULL) { @@ -1427,21 +1425,21 @@ u8 unref_sub_808D77C(u8 localId) } else { - nObjects = gMapHeader.events->mapObjectCount; + nObjects = gMapHeader.events->eventObjectCount; } for (i = 0; i < nObjects; i ++) { - template = &gSaveBlock1Ptr->mapObjectTemplates[i]; + template = &gSaveBlock1Ptr->eventObjectTemplates[i]; if (template->localId == localId && !FlagGet(template->flagId)) { - return InitFieldObjectStateFromTemplate(template, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup); + return InitEventObjectStateFromTemplate(template, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup); } } } - return NUM_FIELD_OBJECTS; + return NUM_EVENT_OBJECTS; } -static bool8 GetAvailableFieldObjectSlot(u16 localId, u8 mapNum, u8 mapGroup, u8 *result) +static bool8 GetAvailableEventObjectSlot(u16 localId, u8 mapNum, u8 mapGroup, u8 *result) // Looks for an empty slot. // Returns FALSE and the location of the available slot // in *result. @@ -1450,78 +1448,78 @@ static bool8 GetAvailableFieldObjectSlot(u16 localId, u8 mapNum, u8 mapGroup, u8 { u8 i = 0; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (!gMapObjects[i].active) + if (!gEventObjects[i].active) break; - if (gMapObjects[i].localId == localId && gMapObjects[i].mapNum == mapNum && gMapObjects[i].mapGroup == mapGroup) + if (gEventObjects[i].localId == localId && gEventObjects[i].mapNum == mapNum && gEventObjects[i].mapGroup == mapGroup) return TRUE; } - if (i >= NUM_FIELD_OBJECTS) + if (i >= NUM_EVENT_OBJECTS) return TRUE; *result = i; do { - if (gMapObjects[i].active && gMapObjects[i].localId == localId && gMapObjects[i].mapNum == mapNum && gMapObjects[i].mapGroup == mapGroup) + if (gEventObjects[i].active && gEventObjects[i].localId == localId && gEventObjects[i].mapNum == mapNum && gEventObjects[i].mapGroup == mapGroup) return TRUE; i ++; - } while (i < NUM_FIELD_OBJECTS); + } while (i < NUM_EVENT_OBJECTS); return FALSE; } -static void RemoveFieldObject(struct MapObject *mapObject) +static void RemoveEventObject(struct EventObject *eventObject) { - mapObject->active = FALSE; - RemoveFieldObjectInternal(mapObject); + eventObject->active = FALSE; + RemoveEventObjectInternal(eventObject); } -void RemoveFieldObjectByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +void RemoveEventObjectByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { u8 index; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &index)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &index)) { - FlagSet(GetFieldObjectFlagIdByFieldObjectId(index)); - RemoveFieldObject(&gMapObjects[index]); + FlagSet(GetEventObjectFlagIdByEventObjectId(index)); + RemoveEventObject(&gEventObjects[index]); } } -static void RemoveFieldObjectInternal(struct MapObject *mapObject) +static void RemoveEventObjectInternal(struct EventObject *eventObject) { struct SpriteFrameImage image; - image.size = GetFieldObjectGraphicsInfo(mapObject->graphicsId)->size; - gSprites[mapObject->spriteId].images = ℑ - DestroySprite(&gSprites[mapObject->spriteId]); + image.size = GetEventObjectGraphicsInfo(eventObject->graphicsId)->size; + gSprites[eventObject->spriteId].images = ℑ + DestroySprite(&gSprites[eventObject->spriteId]); } void unref_sub_808D958(void) { u8 i; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (i != gPlayerAvatar.mapObjectId) + if (i != gPlayerAvatar.eventObjectId) { - RemoveFieldObject(&gMapObjects[i]); + RemoveEventObject(&gEventObjects[i]); } } } -static u8 SpawnFieldObjectInternal(struct MapObjectTemplate *mapObjectTemplate, struct SpriteTemplate *spriteTemplate, u8 mapNum, u8 mapGroup, s16 cameraX, s16 cameraY) +static u8 SpawnEventObjectInternal(struct EventObjectTemplate *eventObjectTemplate, struct SpriteTemplate *spriteTemplate, u8 mapNum, u8 mapGroup, s16 cameraX, s16 cameraY) { - struct MapObject *mapObject; - const struct MapObjectGraphicsInfo *graphicsInfo; + struct EventObject *eventObject; + const struct EventObjectGraphicsInfo *graphicsInfo; struct Sprite *sprite; - u8 mapObjectId; + u8 eventObjectId; u8 paletteSlot; u8 spriteId; - mapObjectId = InitFieldObjectStateFromTemplate(mapObjectTemplate, mapNum, mapGroup); - if (mapObjectId == NUM_FIELD_OBJECTS) + eventObjectId = InitEventObjectStateFromTemplate(eventObjectTemplate, mapNum, mapGroup); + if (eventObjectId == NUM_EVENT_OBJECTS) { - return NUM_FIELD_OBJECTS; + return NUM_EVENT_OBJECTS; } - mapObject = &gMapObjects[mapObjectId]; - graphicsInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); + eventObject = &gEventObjects[eventObjectId]; + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); paletteSlot = graphicsInfo->paletteSlot; if (paletteSlot == 0) { @@ -1536,110 +1534,110 @@ static u8 SpawnFieldObjectInternal(struct MapObjectTemplate *mapObjectTemplate, paletteSlot -= 16; sub_808EAB0(graphicsInfo->paletteTag1, paletteSlot); } - if (mapObject->movementType == 0x4c) + if (eventObject->movementType == 0x4c) { - mapObject->invisible = TRUE; + eventObject->invisible = TRUE; } *(u16 *)&spriteTemplate->paletteTag = 0xFFFF; spriteId = CreateSprite(spriteTemplate, 0, 0, 0); if (spriteId == MAX_SPRITES) { - gMapObjects[mapObjectId].active = FALSE; - return NUM_FIELD_OBJECTS; + gEventObjects[eventObjectId].active = FALSE; + return NUM_EVENT_OBJECTS; } sprite = &gSprites[spriteId]; - sub_8092FF0(mapObject->currentCoords.x + cameraX, mapObject->currentCoords.y + cameraY, &sprite->pos1.x, &sprite->pos1.y); + sub_8092FF0(eventObject->currentCoords.x + cameraX, eventObject->currentCoords.y + cameraY, &sprite->pos1.x, &sprite->pos1.y); sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); sprite->pos1.x += 8; sprite->pos1.y += 16 + sprite->centerToCornerVecY; sprite->oam.paletteNum = paletteSlot; sprite->coordOffsetEnabled = TRUE; - sprite->data[0] = mapObjectId; - mapObject->spriteId = spriteId; - mapObject->inanimate = graphicsInfo->inanimate; - if (!mapObject->inanimate) + sprite->data[0] = eventObjectId; + eventObject->spriteId = spriteId; + eventObject->inanimate = graphicsInfo->inanimate; + if (!eventObject->inanimate) { - StartSpriteAnim(sprite, FieldObjectDirectionToImageAnimId(mapObject->facingDirection)); + StartSpriteAnim(sprite, EventObjectDirectionToImageAnimId(eventObject->facingDirection)); } - SetObjectSubpriorityByZCoord(mapObject->previousElevation, sprite, 1); - sub_8096518(mapObject, sprite); - return mapObjectId; + SetObjectSubpriorityByZCoord(eventObject->previousElevation, sprite, 1); + sub_8096518(eventObject, sprite); + return eventObjectId; } -static u8 SpawnFieldObject(struct MapObjectTemplate *mapObjectTemplate, u8 mapNum, u8 mapGroup, s16 cameraX, s16 cameraY) +static u8 SpawnEventObject(struct EventObjectTemplate *eventObjectTemplate, u8 mapNum, u8 mapGroup, s16 cameraX, s16 cameraY) { - const struct MapObjectGraphicsInfo *graphicsInfo; + const struct EventObjectGraphicsInfo *graphicsInfo; struct SpriteTemplate spriteTemplate; const struct SubspriteTable *subspriteTables; struct SpriteFrameImage spriteFrameImage; - u8 mapObjectId; + u8 eventObjectId; subspriteTables = NULL; - graphicsInfo = GetFieldObjectGraphicsInfo(mapObjectTemplate->graphicsId); - MakeObjectTemplateFromFieldObjectTemplate(mapObjectTemplate, &spriteTemplate, &subspriteTables); + graphicsInfo = GetEventObjectGraphicsInfo(eventObjectTemplate->graphicsId); + MakeObjectTemplateFromEventObjectTemplate(eventObjectTemplate, &spriteTemplate, &subspriteTables); spriteFrameImage.size = graphicsInfo->size; spriteTemplate.images = &spriteFrameImage; - mapObjectId = SpawnFieldObjectInternal(mapObjectTemplate, &spriteTemplate, mapNum, mapGroup, cameraX, cameraY); - if (mapObjectId == NUM_FIELD_OBJECTS) + eventObjectId = SpawnEventObjectInternal(eventObjectTemplate, &spriteTemplate, mapNum, mapGroup, cameraX, cameraY); + if (eventObjectId == NUM_EVENT_OBJECTS) { - return NUM_FIELD_OBJECTS; + return NUM_EVENT_OBJECTS; } - gSprites[gMapObjects[mapObjectId].spriteId].images = graphicsInfo->images; + gSprites[gEventObjects[eventObjectId].spriteId].images = graphicsInfo->images; if (subspriteTables != NULL) { - SetSubspriteTables(&gSprites[gMapObjects[mapObjectId].spriteId], subspriteTables); + SetSubspriteTables(&gSprites[gEventObjects[eventObjectId].spriteId], subspriteTables); } - return mapObjectId; + return eventObjectId; } -u8 SpawnSpecialFieldObject(struct MapObjectTemplate *mapObjectTemplate) +u8 SpawnSpecialEventObject(struct EventObjectTemplate *eventObjectTemplate) { s16 cameraX; s16 cameraY; - GetFieldObjectMovingCameraOffset(&cameraX, &cameraY); - return SpawnFieldObject(mapObjectTemplate, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, cameraX, cameraY); + GetEventObjectMovingCameraOffset(&cameraX, &cameraY); + return SpawnEventObject(eventObjectTemplate, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, cameraX, cameraY); } -u8 SpawnSpecialFieldObjectParametrized(u8 graphicsId, u8 movementBehavior, u8 localId, s16 x, s16 y, u8 z) +u8 SpawnSpecialEventObjectParametrized(u8 graphicsId, u8 movementBehavior, u8 localId, s16 x, s16 y, u8 z) { - struct MapObjectTemplate mapObjectTemplate; + struct EventObjectTemplate eventObjectTemplate; x -= 7; y -= 7; - mapObjectTemplate.localId = localId; - mapObjectTemplate.graphicsId = graphicsId; - mapObjectTemplate.unk2 = 0; - mapObjectTemplate.x = x; - mapObjectTemplate.y = y; - mapObjectTemplate.elevation = z; - mapObjectTemplate.movementType = movementBehavior; - mapObjectTemplate.movementRangeX = 0; - mapObjectTemplate.movementRangeY = 0; - mapObjectTemplate.trainerType = 0; - mapObjectTemplate.trainerRange_berryTreeId = 0; - return SpawnSpecialFieldObject(&mapObjectTemplate); + eventObjectTemplate.localId = localId; + eventObjectTemplate.graphicsId = graphicsId; + eventObjectTemplate.unk2 = 0; + eventObjectTemplate.x = x; + eventObjectTemplate.y = y; + eventObjectTemplate.elevation = z; + eventObjectTemplate.movementType = movementBehavior; + eventObjectTemplate.movementRangeX = 0; + eventObjectTemplate.movementRangeY = 0; + eventObjectTemplate.trainerType = 0; + eventObjectTemplate.trainerRange_berryTreeId = 0; + return SpawnSpecialEventObject(&eventObjectTemplate); } u8 show_sprite(u8 localId, u8 mapNum, u8 mapGroup) { - struct MapObjectTemplate *mapObjectTemplate; + struct EventObjectTemplate *eventObjectTemplate; s16 cameraX; s16 cameraY; - mapObjectTemplate = GetFieldObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup); - if (mapObjectTemplate == NULL) + eventObjectTemplate = GetEventObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup); + if (eventObjectTemplate == NULL) { - return NUM_FIELD_OBJECTS; + return NUM_EVENT_OBJECTS; } - GetFieldObjectMovingCameraOffset(&cameraX, &cameraY); - return SpawnFieldObject(mapObjectTemplate, mapNum, mapGroup, cameraX, cameraY); + GetEventObjectMovingCameraOffset(&cameraX, &cameraY); + return SpawnEventObject(eventObjectTemplate, mapNum, mapGroup, cameraX, cameraY); } -static void MakeObjectTemplateFromFieldObjectGraphicsInfo(u16 graphicsId, void (*callback)(struct Sprite *), struct SpriteTemplate *sprTemplate, const struct SubspriteTable **subspriteTables) +static void MakeObjectTemplateFromEventObjectGraphicsInfo(u16 graphicsId, void (*callback)(struct Sprite *), struct SpriteTemplate *sprTemplate, const struct SubspriteTable **subspriteTables) { - const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(graphicsId); + const struct EventObjectGraphicsInfo *gfxInfo = GetEventObjectGraphicsInfo(graphicsId); sprTemplate->tileTag = gfxInfo->tileTag; sprTemplate->paletteTag = gfxInfo->paletteTag1; @@ -1651,17 +1649,17 @@ static void MakeObjectTemplateFromFieldObjectGraphicsInfo(u16 graphicsId, void ( *subspriteTables = gfxInfo->subspriteTables; } -static void MakeObjectTemplateFromFieldObjectGraphicsInfoWithCallbackIndex(u16 graphicsId, u16 callbackIndex, struct SpriteTemplate *sprTemplate, const struct SubspriteTable **subspriteTables) +static void MakeObjectTemplateFromEventObjectGraphicsInfoWithCallbackIndex(u16 graphicsId, u16 callbackIndex, struct SpriteTemplate *sprTemplate, const struct SubspriteTable **subspriteTables) { - MakeObjectTemplateFromFieldObjectGraphicsInfo(graphicsId, gUnknown_08505438[callbackIndex], sprTemplate, subspriteTables); + MakeObjectTemplateFromEventObjectGraphicsInfo(graphicsId, gUnknown_08505438[callbackIndex], sprTemplate, subspriteTables); } -static void MakeObjectTemplateFromFieldObjectTemplate(struct MapObjectTemplate *mapObjectTemplate, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) +static void MakeObjectTemplateFromEventObjectTemplate(struct EventObjectTemplate *eventObjectTemplate, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) { - MakeObjectTemplateFromFieldObjectGraphicsInfoWithCallbackIndex(mapObjectTemplate->graphicsId, mapObjectTemplate->movementType, spriteTemplate, subspriteTables); + MakeObjectTemplateFromEventObjectGraphicsInfoWithCallbackIndex(eventObjectTemplate->graphicsId, eventObjectTemplate->movementType, spriteTemplate, subspriteTables); } -u8 AddPseudoFieldObject(u16 graphicsId, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority) +u8 AddPseudoEventObject(u16 graphicsId, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority) { struct SpriteTemplate *spriteTemplate; const struct SubspriteTable *subspriteTables; @@ -1669,7 +1667,7 @@ u8 AddPseudoFieldObject(u16 graphicsId, void (*callback)(struct Sprite *), s16 x u8 spriteIdx; spriteTemplate = malloc(sizeof(struct SpriteTemplate)); - MakeObjectTemplateFromFieldObjectGraphicsInfo(graphicsId, callback, spriteTemplate, &subspriteTables); + MakeObjectTemplateFromEventObjectGraphicsInfo(graphicsId, callback, spriteTemplate, &subspriteTables); if (spriteTemplate->paletteTag != 0xffff) { sub_808E894(spriteTemplate->paletteTag); @@ -1688,14 +1686,14 @@ u8 AddPseudoFieldObject(u16 graphicsId, void (*callback)(struct Sprite *), s16 x u8 sprite_new(u8 graphicsId, u8 a1, s16 x, s16 y, u8 z, u8 direction) { - const struct MapObjectGraphicsInfo *graphicsInfo; + const struct EventObjectGraphicsInfo *graphicsInfo; struct SpriteTemplate spriteTemplate; const struct SubspriteTable *subspriteTables; u8 spriteId; struct Sprite *sprite; - graphicsInfo = GetFieldObjectGraphicsInfo(graphicsId); - MakeObjectTemplateFromFieldObjectGraphicsInfo(graphicsId, sub_8097AC8, &spriteTemplate, &subspriteTables); + graphicsInfo = GetEventObjectGraphicsInfo(graphicsId); + MakeObjectTemplateFromEventObjectGraphicsInfo(graphicsId, sub_8097AC8, &spriteTemplate, &subspriteTables); *(u16 *)&spriteTemplate.paletteTag = 0xffff; x += 7; y += 7; @@ -1730,12 +1728,12 @@ u8 sprite_new(u8 graphicsId, u8 a1, s16 x, s16 y, u8 z, u8 direction) } InitObjectPriorityByZCoord(sprite, z); SetObjectSubpriorityByZCoord(z, sprite, 1); - StartSpriteAnim(sprite, FieldObjectDirectionToImageAnimId(direction)); + StartSpriteAnim(sprite, EventObjectDirectionToImageAnimId(direction)); } return spriteId; } -void SpawnFieldObjectsInView(s16 cameraX, s16 cameraY) +void SpawnEventObjectsInView(s16 cameraX, s16 cameraY) { u8 i; s16 left; @@ -1763,47 +1761,47 @@ void SpawnFieldObjectsInView(s16 cameraX, s16 cameraY) } else { - objectCount = gMapHeader.events->mapObjectCount; + objectCount = gMapHeader.events->eventObjectCount; } for (i = 0; i < objectCount; i++) { - struct MapObjectTemplate *template = &gSaveBlock1Ptr->mapObjectTemplates[i]; + struct EventObjectTemplate *template = &gSaveBlock1Ptr->eventObjectTemplates[i]; npcX = template->x + 7; npcY = template->y + 7; if (top <= npcY && bottom >= npcY && left <= npcX && right >= npcX && !FlagGet(template->flagId)) - SpawnFieldObject(template, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, cameraX, cameraY); + SpawnEventObject(template, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, cameraX, cameraY); } } } -/*static*/ void RemoveFieldObjectsOutsideView(void) +/*static*/ void RemoveEventObjectsOutsideView(void) { u8 i; u8 j; bool8 isActiveLinkPlayer; - struct MapObject *mapObject; + struct EventObject *eventObject; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - for (j = 0, isActiveLinkPlayer = FALSE; j < ARRAY_COUNT(gLinkPlayerMapObjects); j ++) + for (j = 0, isActiveLinkPlayer = FALSE; j < ARRAY_COUNT(gLinkPlayerEventObjects); j ++) { - if (gLinkPlayerMapObjects[j].active && i == gLinkPlayerMapObjects[j].mapObjId) + if (gLinkPlayerEventObjects[j].active && i == gLinkPlayerEventObjects[j].eventObjId) isActiveLinkPlayer = TRUE; } if (!isActiveLinkPlayer) { - mapObject = &gMapObjects[i]; + eventObject = &gEventObjects[i]; - if (mapObject->active && !mapObject->isPlayer) - RemoveFieldObjectIfOutsideView(mapObject); + if (eventObject->active && !eventObject->isPlayer) + RemoveEventObjectIfOutsideView(eventObject); } } } -static void RemoveFieldObjectIfOutsideView(struct MapObject *mapObject) +static void RemoveEventObjectIfOutsideView(struct EventObject *eventObject) { s16 left; s16 right; @@ -1815,13 +1813,13 @@ static void RemoveFieldObjectIfOutsideView(struct MapObject *mapObject) top = gSaveBlock1Ptr->pos.y; bottom = gSaveBlock1Ptr->pos.y + 16; - if (mapObject->currentCoords.x >= left && mapObject->currentCoords.x <= right - && mapObject->currentCoords.y >= top && mapObject->currentCoords.y <= bottom) + if (eventObject->currentCoords.x >= left && eventObject->currentCoords.x <= right + && eventObject->currentCoords.y >= top && eventObject->currentCoords.y <= bottom) return; - if (mapObject->initialCoords.x >= left && mapObject->initialCoords.x <= right - && mapObject->initialCoords.y >= top && mapObject->initialCoords.y <= bottom) + if (eventObject->initialCoords.x >= left && eventObject->initialCoords.x <= right + && eventObject->initialCoords.y >= top && eventObject->initialCoords.y <= bottom) return; - RemoveFieldObject(mapObject); + RemoveEventObject(eventObject); } void sub_808E16C(s16 x, s16 y) @@ -1829,9 +1827,9 @@ void sub_808E16C(s16 x, s16 y) u8 i; ClearPlayerAvatarInfo(); - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (gMapObjects[i].active) + if (gEventObjects[i].active) { sub_808E1B8(i, x, y); } @@ -1839,32 +1837,32 @@ void sub_808E16C(s16 x, s16 y) sub_808D450(); } -static void sub_808E1B8(u8 mapObjectId, s16 x, s16 y) +static void sub_808E1B8(u8 eventObjectId, s16 x, s16 y) { u8 spriteId; u8 paletteSlot; - struct MapObject *mapObject; + struct EventObject *eventObject; const struct SubspriteTable *subspriteTables; - const struct MapObjectGraphicsInfo *graphicsInfo; + const struct EventObjectGraphicsInfo *graphicsInfo; struct SpriteFrameImage spriteFrameImage; struct SpriteTemplate spriteTemplate; struct Sprite *sprite; #define i spriteId - for (i = 0; i < ARRAY_COUNT(gLinkPlayerMapObjects); i ++) + for (i = 0; i < ARRAY_COUNT(gLinkPlayerEventObjects); i ++) { - if (gLinkPlayerMapObjects[i].active && mapObjectId == gLinkPlayerMapObjects[i].mapObjId) + if (gLinkPlayerEventObjects[i].active && eventObjectId == gLinkPlayerEventObjects[i].eventObjId) { return; } } #undef i - mapObject = &gMapObjects[mapObjectId]; + eventObject = &gEventObjects[eventObjectId]; subspriteTables = NULL; - graphicsInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); spriteFrameImage.size = graphicsInfo->size; - MakeObjectTemplateFromFieldObjectGraphicsInfoWithCallbackIndex(mapObject->graphicsId, mapObject->movementType, &spriteTemplate, &subspriteTables); + MakeObjectTemplateFromEventObjectGraphicsInfoWithCallbackIndex(eventObject->graphicsId, eventObject->movementType, &spriteTemplate, &subspriteTables); spriteTemplate.images = &spriteFrameImage; *(u16 *)&spriteTemplate.paletteTag = 0xffff; paletteSlot = graphicsInfo->paletteSlot; @@ -1886,16 +1884,16 @@ static void sub_808E1B8(u8 mapObjectId, s16 x, s16 y) if (spriteId != MAX_SPRITES) { sprite = &gSprites[spriteId]; - sub_8092FF0(x + mapObject->currentCoords.x, y + mapObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); + sub_8092FF0(x + eventObject->currentCoords.x, y + eventObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); sprite->pos1.x += 8; sprite->pos1.y += 16 + sprite->centerToCornerVecY; sprite->images = graphicsInfo->images; - if (mapObject->movementType == 0x0b) + if (eventObject->movementType == 0x0b) { - SetPlayerAvatarFieldObjectIdAndObjectId(mapObjectId, spriteId); - mapObject->warpArrowSpriteId = sub_8154228(); + SetPlayerAvatarEventObjectIdAndObjectId(eventObjectId, spriteId); + eventObject->warpArrowSpriteId = sub_8154228(); } if (subspriteTables != NULL) { @@ -1903,46 +1901,46 @@ static void sub_808E1B8(u8 mapObjectId, s16 x, s16 y) } sprite->oam.paletteNum = paletteSlot; sprite->coordOffsetEnabled = TRUE; - sprite->data[0] = mapObjectId; - mapObject->spriteId = spriteId; - if (!mapObject->inanimate && mapObject->movementType != 0x0b) + sprite->data[0] = eventObjectId; + eventObject->spriteId = spriteId; + if (!eventObject->inanimate && eventObject->movementType != 0x0b) { - StartSpriteAnim(sprite, FieldObjectDirectionToImageAnimId(mapObject->facingDirection)); + StartSpriteAnim(sprite, EventObjectDirectionToImageAnimId(eventObject->facingDirection)); } - sub_808E38C(mapObject); - SetObjectSubpriorityByZCoord(mapObject->previousElevation, sprite, 1); + sub_808E38C(eventObject); + SetObjectSubpriorityByZCoord(eventObject->previousElevation, sprite, 1); } } -static void sub_808E38C(struct MapObject *mapObject) +static void sub_808E38C(struct EventObject *eventObject) { - mapObject->singleMovementActive = FALSE; - mapObject->triggerGroundEffectsOnMove = TRUE; - mapObject->hasShadow = FALSE; - mapObject->hasReflection = FALSE; - mapObject->inShortGrass = FALSE; - mapObject->inShallowFlowingWater = FALSE; - mapObject->inSandPile = FALSE; - mapObject->inHotSprings = FALSE; - FieldObjectClearAnim(mapObject); + eventObject->singleMovementActive = FALSE; + eventObject->triggerGroundEffectsOnMove = TRUE; + eventObject->hasShadow = FALSE; + eventObject->hasReflection = FALSE; + eventObject->inShortGrass = FALSE; + eventObject->inShallowFlowingWater = FALSE; + eventObject->inSandPile = FALSE; + eventObject->inHotSprings = FALSE; + EventObjectClearAnim(eventObject); } -static void SetPlayerAvatarFieldObjectIdAndObjectId(u8 mapObjectId, u8 spriteId) +static void SetPlayerAvatarEventObjectIdAndObjectId(u8 eventObjectId, u8 spriteId) { - gPlayerAvatar.mapObjectId = mapObjectId; + gPlayerAvatar.eventObjectId = eventObjectId; gPlayerAvatar.spriteId = spriteId; - gPlayerAvatar.gender = GetPlayerAvatarGenderByGraphicsId(gMapObjects[mapObjectId].graphicsId); - SetPlayerAvatarExtraStateTransition(gMapObjects[mapObjectId].graphicsId, 0x20); + gPlayerAvatar.gender = GetPlayerAvatarGenderByGraphicsId(gEventObjects[eventObjectId].graphicsId); + SetPlayerAvatarExtraStateTransition(gEventObjects[eventObjectId].graphicsId, 0x20); } -void FieldObjectSetGraphicsId(struct MapObject *mapObject, u8 graphicsId) +void EventObjectSetGraphicsId(struct EventObject *eventObject, u8 graphicsId) { - const struct MapObjectGraphicsInfo *graphicsInfo; + const struct EventObjectGraphicsInfo *graphicsInfo; struct Sprite *sprite; u8 paletteSlot; - graphicsInfo = GetFieldObjectGraphicsInfo(graphicsId); - sprite = &gSprites[mapObject->spriteId]; + graphicsInfo = GetEventObjectGraphicsInfo(graphicsId); + sprite = &gSprites[eventObject->spriteId]; paletteSlot = graphicsInfo->paletteSlot; if (paletteSlot == 0) { @@ -1963,86 +1961,86 @@ void FieldObjectSetGraphicsId(struct MapObject *mapObject, u8 graphicsId) sprite->anims = graphicsInfo->anims; sprite->subspriteTables = graphicsInfo->subspriteTables; sprite->oam.paletteNum = paletteSlot; - mapObject->inanimate = graphicsInfo->inanimate; - mapObject->graphicsId = graphicsId; - sub_8093038(mapObject->currentCoords.x, mapObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); + eventObject->inanimate = graphicsInfo->inanimate; + eventObject->graphicsId = graphicsId; + sub_8093038(eventObject->currentCoords.x, eventObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); sprite->pos1.x += 8; sprite->pos1.y += 16 + sprite->centerToCornerVecY; - if (mapObject->trackedByCamera) + if (eventObject->trackedByCamera) { CameraObjectReset1(); } } -void FieldObjectSetGraphicsIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 graphicsId) +void EventObjectSetGraphicsIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 graphicsId) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { - FieldObjectSetGraphicsId(&gMapObjects[mapObjectId], graphicsId); + EventObjectSetGraphicsId(&gEventObjects[eventObjectId], graphicsId); } } -void FieldObjectTurn(struct MapObject *mapObject, u8 direction) +void EventObjectTurn(struct EventObject *eventObject, u8 direction) { - FieldObjectSetDirection(mapObject, direction); - if (!mapObject->inanimate) + EventObjectSetDirection(eventObject, direction); + if (!eventObject->inanimate) { - StartSpriteAnim(&gSprites[mapObject->spriteId], FieldObjectDirectionToImageAnimId(mapObject->facingDirection)); - SeekSpriteAnim(&gSprites[mapObject->spriteId], 0); + StartSpriteAnim(&gSprites[eventObject->spriteId], EventObjectDirectionToImageAnimId(eventObject->facingDirection)); + SeekSpriteAnim(&gSprites[eventObject->spriteId], 0); } } -void FieldObjectTurnByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 direction) +void EventObjectTurnByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 direction) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { - FieldObjectTurn(&gMapObjects[mapObjectId], direction); + EventObjectTurn(&gEventObjects[eventObjectId], direction); } } void PlayerObjectTurn(struct PlayerAvatar *playerAvatar, u8 direction) { - FieldObjectTurn(&gMapObjects[playerAvatar->mapObjectId], direction); + EventObjectTurn(&gEventObjects[playerAvatar->eventObjectId], direction); } -/*static*/ void get_berry_tree_graphics(struct MapObject *mapObject, struct Sprite *sprite) +/*static*/ void get_berry_tree_graphics(struct EventObject *eventObject, struct Sprite *sprite) { u8 berryStage; u8 berryId; - mapObject->invisible = TRUE; + eventObject->invisible = TRUE; sprite->invisible = TRUE; - berryStage = GetStageByBerryTreeId(mapObject->trainerRange_berryTreeId); + berryStage = GetStageByBerryTreeId(eventObject->trainerRange_berryTreeId); if (berryStage != 0) { - mapObject->invisible = FALSE; + eventObject->invisible = FALSE; sprite->invisible = FALSE; - berryId = GetBerryTypeByBerryTreeId(mapObject->trainerRange_berryTreeId) - 1; + berryId = GetBerryTypeByBerryTreeId(eventObject->trainerRange_berryTreeId) - 1; berryStage -= 1; if (berryId >= NUM_BERRIES) { berryId = 0; } - FieldObjectSetGraphicsId(mapObject, gBerryTreeFieldObjectGraphicsIdTablePointers[berryId][berryStage]); + EventObjectSetGraphicsId(eventObject, gBerryTreeEventObjectGraphicsIdTablePointers[berryId][berryStage]); sprite->images = gBerryTreePicTablePointers[berryId]; sprite->oam.paletteNum = gBerryTreePaletteSlotTablePointers[berryId][berryStage]; StartSpriteAnim(sprite, berryStage); } } -const struct MapObjectGraphicsInfo *GetFieldObjectGraphicsInfo(u8 graphicsId) +const struct EventObjectGraphicsInfo *GetEventObjectGraphicsInfo(u8 graphicsId) { u8 bard; if (graphicsId >= SPRITE_VAR) { - graphicsId = VarGetFieldObjectGraphicsId(graphicsId - SPRITE_VAR); + graphicsId = VarGetEventObjectGraphicsId(graphicsId - SPRITE_VAR); } if (graphicsId == 0x45) { @@ -2053,83 +2051,83 @@ const struct MapObjectGraphicsInfo *GetFieldObjectGraphicsInfo(u8 graphicsId) { graphicsId = 0x05; // LittleBoy1 } - return gFieldObjectGraphicsInfoPointers[graphicsId]; + return gEventObjectGraphicsInfoPointers[graphicsId]; } -static void FieldObjectHandleDynamicGraphicsId(struct MapObject *mapObject) +static void EventObjectHandleDynamicGraphicsId(struct EventObject *eventObject) { - if (mapObject->graphicsId >= SPRITE_VAR) + if (eventObject->graphicsId >= SPRITE_VAR) { - mapObject->graphicsId = VarGetFieldObjectGraphicsId(mapObject->graphicsId - SPRITE_VAR); + eventObject->graphicsId = VarGetEventObjectGraphicsId(eventObject->graphicsId - SPRITE_VAR); } } void npc_by_local_id_and_map_set_field_1_bit_x20(u8 localId, u8 mapNum, u8 mapGroup, u8 state) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { - gMapObjects[mapObjectId].invisible = state; + gEventObjects[eventObjectId].invisible = state; } } -void FieldObjectGetLocalIdAndMap(struct MapObject *mapObject, void *localId, void *mapNum, void *mapGroup) +void EventObjectGetLocalIdAndMap(struct EventObject *eventObject, void *localId, void *mapNum, void *mapGroup) { - *(u8*)(localId) = mapObject->localId; - *(u8*)(mapNum) = mapObject->mapNum; - *(u8*)(mapGroup) = mapObject->mapGroup; + *(u8*)(localId) = eventObject->localId; + *(u8*)(mapNum) = eventObject->mapNum; + *(u8*)(mapGroup) = eventObject->mapGroup; } void sub_808E75C(s16 x, s16 y) { - u8 mapObjectId; - struct MapObject *mapObject; + u8 eventObjectId; + struct EventObject *eventObject; - mapObjectId = GetFieldObjectIdByXY(x, y); - if (mapObjectId != NUM_FIELD_OBJECTS) + eventObjectId = GetEventObjectIdByXY(x, y); + if (eventObjectId != NUM_EVENT_OBJECTS) { - mapObject = &gMapObjects[mapObjectId]; - mapObject->triggerGroundEffectsOnMove = TRUE; + eventObject = &gEventObjects[eventObjectId]; + eventObject->triggerGroundEffectsOnMove = TRUE; } } void sub_808E78C(u8 localId, u8 mapNum, u8 mapGroup, u8 subpriority) { - u8 mapObjectId; - struct MapObject *mapObject; + u8 eventObjectId; + struct EventObject *eventObject; struct Sprite *sprite; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { - mapObject = &gMapObjects[mapObjectId]; - sprite = &gSprites[mapObject->spriteId]; - mapObject->fixedPriority = TRUE; + eventObject = &gEventObjects[eventObjectId]; + sprite = &gSprites[eventObject->spriteId]; + eventObject->fixedPriority = TRUE; sprite->subpriority = subpriority; } } void sub_808E7E4(u8 localId, u8 mapNum, u8 mapGroup) { - u8 mapObjectId; - struct MapObject *mapObject; + u8 eventObjectId; + struct EventObject *eventObject; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { - mapObject = &gMapObjects[mapObjectId]; - mapObject->fixedPriority = FALSE; - mapObject->triggerGroundEffectsOnMove = TRUE; + eventObject = &gEventObjects[eventObjectId]; + eventObject->fixedPriority = FALSE; + eventObject->triggerGroundEffectsOnMove = TRUE; } } void sub_808E82C(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y) { - u8 mapObjectId; + u8 eventObjectId; struct Sprite *sprite; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { - sprite = &gSprites[gMapObjects[mapObjectId].spriteId]; + sprite = &gSprites[gEventObjects[eventObjectId].spriteId]; sprite->pos2.x = x; sprite->pos2.y = y; } @@ -2145,7 +2143,7 @@ static void sub_808E894(u16 paletteTag) { u16 paletteSlot; - paletteSlot = FindFieldObjectPaletteIndexByTag(paletteTag); + paletteSlot = FindEventObjectPaletteIndexByTag(paletteTag); if (paletteSlot != 0x11ff) // always true { sub_808E8F4(&gUnknown_0850BBC8[paletteSlot]); @@ -2175,7 +2173,7 @@ void pal_patch_for_npc(u16 paletteTag, u8 paletteSlot) { u16 paletteIdx; - paletteIdx = FindFieldObjectPaletteIndexByTag(paletteTag); + paletteIdx = FindEventObjectPaletteIndexByTag(paletteTag); LoadPalette(gUnknown_0850BBC8[paletteIdx].data, 16 * paletteSlot + 256, 0x20); } @@ -2189,7 +2187,7 @@ void pal_patch_for_npc_range(const u16 *paletteTags, u8 minSlot, u8 maxSlot) } } -static u8 FindFieldObjectPaletteIndexByTag(u16 tag) +static u8 FindEventObjectPaletteIndexByTag(u16 tag) { u8 i; @@ -2239,45 +2237,45 @@ static void sub_808EAB0(u16 tag, u8 slot) pal_patch_for_npc(tag, slot); } -void unref_sub_808EAC4(struct MapObject *mapObject, s16 x, s16 y) +void unref_sub_808EAC4(struct EventObject *eventObject, s16 x, s16 y) { - mapObject->previousCoords.x = mapObject->currentCoords.x; - mapObject->previousCoords.y = mapObject->currentCoords.y; - mapObject->currentCoords.x += x; - mapObject->currentCoords.y += y; + eventObject->previousCoords.x = eventObject->currentCoords.x; + eventObject->previousCoords.y = eventObject->currentCoords.y; + eventObject->currentCoords.x += x; + eventObject->currentCoords.y += y; } -void npc_coords_shift(struct MapObject *mapObject, s16 x, s16 y) +void npc_coords_shift(struct EventObject *eventObject, s16 x, s16 y) { - mapObject->previousCoords.x = mapObject->currentCoords.x; - mapObject->previousCoords.y = mapObject->currentCoords.y; - mapObject->currentCoords.x = x; - mapObject->currentCoords.y = y; + eventObject->previousCoords.x = eventObject->currentCoords.x; + eventObject->previousCoords.y = eventObject->currentCoords.y; + eventObject->currentCoords.x = x; + eventObject->currentCoords.y = y; } -/*static*/ void npc_coords_set(struct MapObject *mapObject, s16 x, s16 y) +/*static*/ void npc_coords_set(struct EventObject *eventObject, s16 x, s16 y) { - mapObject->previousCoords.x = x; - mapObject->previousCoords.y = y; - mapObject->currentCoords.x = x; - mapObject->currentCoords.y = y; + eventObject->previousCoords.x = x; + eventObject->previousCoords.y = y; + eventObject->currentCoords.x = x; + eventObject->currentCoords.y = y; } -void sub_808EB08(struct MapObject *mapObject, s16 x, s16 y) +void sub_808EB08(struct EventObject *eventObject, s16 x, s16 y) { struct Sprite *sprite; - const struct MapObjectGraphicsInfo *graphicsInfo; + const struct EventObjectGraphicsInfo *graphicsInfo; - sprite = &gSprites[mapObject->spriteId]; - graphicsInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); - npc_coords_set(mapObject, x, y); - sub_8093038(mapObject->currentCoords.x, mapObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); + sprite = &gSprites[eventObject->spriteId]; + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + npc_coords_set(eventObject, x, y); + sub_8093038(eventObject->currentCoords.x, eventObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); sprite->centerToCornerVecX = -(graphicsInfo->width >> 1); sprite->centerToCornerVecY = -(graphicsInfo->height >> 1); sprite->pos1.x += 8; sprite->pos1.y += 16 + sprite->centerToCornerVecY; - sub_808E38C(mapObject); - if (mapObject->trackedByCamera) + sub_808E38C(eventObject); + if (eventObject->trackedByCamera) { CameraObjectReset1(); } @@ -2285,22 +2283,22 @@ void sub_808EB08(struct MapObject *mapObject, s16 x, s16 y) void sub_808EBA8(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { x += 7; y += 7; - sub_808EB08(&gMapObjects[mapObjectId], x, y); + sub_808EB08(&gEventObjects[eventObjectId], x, y); } } -void npc_coords_shift_still(struct MapObject *mapObject) +void npc_coords_shift_still(struct EventObject *eventObject) { - npc_coords_shift(mapObject, mapObject->currentCoords.x, mapObject->currentCoords.y); + npc_coords_shift(eventObject, eventObject->currentCoords.x, eventObject->currentCoords.y); } -void UpdateFieldObjectCoordsForCameraUpdate(void) +void UpdateEventObjectCoordsForCameraUpdate(void) { u8 i; s16 dx; @@ -2310,51 +2308,51 @@ void UpdateFieldObjectCoordsForCameraUpdate(void) { dx = gCamera.x; dy = gCamera.y; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (gMapObjects[i].active) + if (gEventObjects[i].active) { - gMapObjects[i].initialCoords.x -= dx; - gMapObjects[i].initialCoords.y -= dy; - gMapObjects[i].currentCoords.x -= dx; - gMapObjects[i].currentCoords.y -= dy; - gMapObjects[i].previousCoords.x -= dx; - gMapObjects[i].previousCoords.y -= dy; + gEventObjects[i].initialCoords.x -= dx; + gEventObjects[i].initialCoords.y -= dy; + gEventObjects[i].currentCoords.x -= dx; + gEventObjects[i].currentCoords.y -= dy; + gEventObjects[i].previousCoords.x -= dx; + gEventObjects[i].previousCoords.y -= dy; } } } } -u8 GetFieldObjectIdByXYZ(u16 x, u16 y, u8 z) +u8 GetEventObjectIdByXYZ(u16 x, u16 y, u8 z) { u8 i; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - if (gMapObjects[i].active) + if (gEventObjects[i].active) { - if (gMapObjects[i].currentCoords.x == x && gMapObjects[i].currentCoords.y == y && FieldObjectDoesZCoordMatch(&gMapObjects[i], z)) + if (gEventObjects[i].currentCoords.x == x && gEventObjects[i].currentCoords.y == y && EventObjectDoesZCoordMatch(&gEventObjects[i], z)) { return i; } } } - return NUM_FIELD_OBJECTS; + return NUM_EVENT_OBJECTS; } -static bool8 FieldObjectDoesZCoordMatch(struct MapObject *mapObject, u8 z) +static bool8 EventObjectDoesZCoordMatch(struct EventObject *eventObject, u8 z) { - if (mapObject->currentElevation != 0 && z != 0 && mapObject->currentElevation != z) + if (eventObject->currentElevation != 0 && z != 0 && eventObject->currentElevation != z) { return FALSE; } return TRUE; } -void UpdateFieldObjectsForCameraUpdate(s16 x, s16 y) +void UpdateEventObjectsForCameraUpdate(s16 x, s16 y) { - UpdateFieldObjectCoordsForCameraUpdate(); - SpawnFieldObjectsInView(x, y); - RemoveFieldObjectsOutsideView(); + UpdateEventObjectCoordsForCameraUpdate(); + SpawnEventObjectsInView(x, y); + RemoveEventObjectsOutsideView(); } u8 AddCameraObject(u8 linkedSpriteId) @@ -2496,91 +2494,91 @@ u8 obj_unfreeze(struct Sprite *sprite, s16 x, s16 y, u8 subpriority) return MAX_SPRITES; } -void FieldObjectSetDirection(struct MapObject *mapObject, u8 direction) +void EventObjectSetDirection(struct EventObject *eventObject, u8 direction) { s8 d2; - mapObject->previousMovementDirection = mapObject->facingDirection; - if (!mapObject->facingDirectionLocked) + eventObject->previousMovementDirection = eventObject->facingDirection; + if (!eventObject->facingDirectionLocked) { d2 = direction; - mapObject->facingDirection = d2; + eventObject->facingDirection = d2; } - mapObject->movementDirection = direction; + eventObject->movementDirection = direction; } -static const u8 *GetFieldObjectScriptPointerByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +static const u8 *GetEventObjectScriptPointerByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { - return GetFieldObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->script; + return GetEventObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->script; } -const u8 *GetFieldObjectScriptPointerByFieldObjectId(u8 mapObjectId) +const u8 *GetEventObjectScriptPointerByEventObjectId(u8 eventObjectId) { - return GetFieldObjectScriptPointerByLocalIdAndMap(gMapObjects[mapObjectId].localId, gMapObjects[mapObjectId].mapNum, gMapObjects[mapObjectId].mapGroup); + return GetEventObjectScriptPointerByLocalIdAndMap(gEventObjects[eventObjectId].localId, gEventObjects[eventObjectId].mapNum, gEventObjects[eventObjectId].mapGroup); } -static u16 GetFieldObjectFlagIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +static u16 GetEventObjectFlagIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { - return GetFieldObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->flagId; + return GetEventObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->flagId; } -static u16 GetFieldObjectFlagIdByFieldObjectId(u8 mapObjectId) +static u16 GetEventObjectFlagIdByEventObjectId(u8 eventObjectId) { - return GetFieldObjectFlagIdByLocalIdAndMap(gMapObjects[mapObjectId].localId, gMapObjects[mapObjectId].mapNum, gMapObjects[mapObjectId].mapGroup); + return GetEventObjectFlagIdByLocalIdAndMap(gEventObjects[eventObjectId].localId, gEventObjects[eventObjectId].mapNum, gEventObjects[eventObjectId].mapGroup); } u8 sub_808F080(u8 localId, u8 mapNum, u8 mapGroup) { - u8 mapObjectId; + u8 eventObjectId; - if (TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { return 0xFF; } - return gMapObjects[mapObjectId].trainerType; + return gEventObjects[eventObjectId].trainerType; } -u8 sub_808F0BC(u8 mapObjectId) +u8 sub_808F0BC(u8 eventObjectId) { - return gMapObjects[mapObjectId].trainerType; + return gEventObjects[eventObjectId].trainerType; } u8 sub_808F0D4(u8 localId, u8 mapNum, u8 mapGroup) { - u8 mapObjectId; + u8 eventObjectId; - if (TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { return 0xFF; } - return gMapObjects[mapObjectId].trainerRange_berryTreeId; + return gEventObjects[eventObjectId].trainerRange_berryTreeId; } -u8 FieldObjectGetBerryTreeId(u8 mapObjectId) +u8 EventObjectGetBerryTreeId(u8 eventObjectId) { - return gMapObjects[mapObjectId].trainerRange_berryTreeId; + return gEventObjects[eventObjectId].trainerRange_berryTreeId; } -static struct MapObjectTemplate *GetFieldObjectTemplateByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +static struct EventObjectTemplate *GetEventObjectTemplateByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { - struct MapObjectTemplate *templates; + struct EventObjectTemplate *templates; const struct MapHeader *mapHeader; u8 count; if (gSaveBlock1Ptr->location.mapNum == mapNum && gSaveBlock1Ptr->location.mapGroup == mapGroup) { - templates = gSaveBlock1Ptr->mapObjectTemplates; - count = gMapHeader.events->mapObjectCount; + templates = gSaveBlock1Ptr->eventObjectTemplates; + count = gMapHeader.events->eventObjectCount; } else { mapHeader = Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum); - templates = mapHeader->events->mapObjects; - count = mapHeader->events->mapObjectCount; + templates = mapHeader->events->eventObjects; + count = mapHeader->events->eventObjectCount; } - return FindFieldObjectTemplateInArrayByLocalId(localId, templates, count); + return FindEventObjectTemplateInArrayByLocalId(localId, templates, count); } -static struct MapObjectTemplate *FindFieldObjectTemplateInArrayByLocalId(u8 localId, struct MapObjectTemplate *templates, u8 count) +static struct EventObjectTemplate *FindEventObjectTemplateInArrayByLocalId(u8 localId, struct EventObjectTemplate *templates, u8 count) { u8 i; @@ -2594,81 +2592,81 @@ static struct MapObjectTemplate *FindFieldObjectTemplateInArrayByLocalId(u8 loca return NULL; } -struct MapObjectTemplate *sub_808F1B4(const struct MapObject *mapObject) +struct EventObjectTemplate *sub_808F1B4(const struct EventObject *eventObject) { int i; - if (mapObject->mapNum != gSaveBlock1Ptr->location.mapNum || mapObject->mapGroup != gSaveBlock1Ptr->location.mapGroup) + if (eventObject->mapNum != gSaveBlock1Ptr->location.mapNum || eventObject->mapGroup != gSaveBlock1Ptr->location.mapGroup) { return NULL; } for (i = 0; i < 64; i ++) // Using ARRAY_COUNT here results in the wrong conditional branch instruction (bls instead of ble) { - if (mapObject->localId == gSaveBlock1Ptr->mapObjectTemplates[i].localId) + if (eventObject->localId == gSaveBlock1Ptr->eventObjectTemplates[i].localId) { - return &gSaveBlock1Ptr->mapObjectTemplates[i]; + return &gSaveBlock1Ptr->eventObjectTemplates[i]; } } return NULL; } -void sub_808F208(const struct MapObject *mapObject) +void sub_808F208(const struct EventObject *eventObject) { - struct MapObjectTemplate *mapObjectTemplate; + struct EventObjectTemplate *eventObjectTemplate; - mapObjectTemplate = sub_808F1B4(mapObject); - if (mapObjectTemplate != NULL) + eventObjectTemplate = sub_808F1B4(eventObject); + if (eventObjectTemplate != NULL) { - mapObjectTemplate->x = mapObject->currentCoords.x - 7; - mapObjectTemplate->y = mapObject->currentCoords.y - 7; + eventObjectTemplate->x = eventObject->currentCoords.x - 7; + eventObjectTemplate->y = eventObject->currentCoords.y - 7; } } -void sub_808F228(const struct MapObject *mapObject, const u8 *script) +void sub_808F228(const struct EventObject *eventObject, const u8 *script) { - struct MapObjectTemplate *mapObjectTemplate; + struct EventObjectTemplate *eventObjectTemplate; - mapObjectTemplate = sub_808F1B4(mapObject); - if (mapObjectTemplate != NULL) + eventObjectTemplate = sub_808F1B4(eventObject); + if (eventObjectTemplate != NULL) { - mapObjectTemplate->script = script; + eventObjectTemplate->script = script; } } -void sub_808F23C(const struct MapObject *mapObject, u8 movementType) +void sub_808F23C(const struct EventObject *eventObject, u8 movementType) { - struct MapObjectTemplate *mapObjectTemplate; + struct EventObjectTemplate *eventObjectTemplate; - mapObjectTemplate = sub_808F1B4(mapObject); - if (mapObjectTemplate != NULL) + eventObjectTemplate = sub_808F1B4(eventObject); + if (eventObjectTemplate != NULL) { - mapObjectTemplate->movementType = movementType; + eventObjectTemplate->movementType = movementType; } } void sub_808F254(u8 localId, u8 mapNum, u8 mapGroup) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { - sub_808F208(&gMapObjects[mapObjectId]); + sub_808F208(&gEventObjects[eventObjectId]); } } void sub_808F28C(u8 localId, u8 mapNum, u8 mapGroup, u8 decorCat) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { switch (decorCat) { case DECORCAT_DOLL: - sub_808F228(&gMapObjects[mapObjectId], EventScript_2766A2); + sub_808F228(&gEventObjects[eventObjectId], EventScript_2766A2); break; case DECORCAT_CUSHION: - sub_808F228(&gMapObjects[mapObjectId], EventScript_2766A6); + sub_808F228(&gEventObjects[eventObjectId], EventScript_2766A6); break; } } @@ -2715,34 +2713,34 @@ null_object_step(NoMovement1, FALSE) field_object_step(GoRandomDirections, gUnknown_0850D6F4) -bool8 sub_808F44C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F44C(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_808F460(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F460(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_808F48C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F48C(struct EventObject *eventObject, struct Sprite *sprite) { - if (!FieldObjectExecRegularAnim(mapObject, sprite)) + if (!EventObjectExecRegularAnim(eventObject, sprite)) { return FALSE; } - SetFieldObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); + SetEventObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); sprite->data[1] = 3; return TRUE; } -bool8 sub_808F4C8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F4C8(struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite)) + if (RunEventObjectStepTimer(sprite)) { sprite->data[1] = 4; return TRUE; @@ -2750,41 +2748,41 @@ bool8 sub_808F4C8(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_808F4E8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F4E8(struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[4]; u8 chosenDirection; memcpy(directions, gUnknown_0850D710, sizeof directions); chosenDirection = directions[Random() & 0x03]; - FieldObjectSetDirection(mapObject, chosenDirection); + EventObjectSetDirection(eventObject, chosenDirection); sprite->data[1] = 5; - if (npc_block_way__next_tile(mapObject, chosenDirection)) + if (npc_block_way__next_tile(eventObject, chosenDirection)) { sprite->data[1] = 1; } return TRUE; } -bool8 sub_808F534(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F534(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->movementDirection)); - mapObject->singleMovementActive = TRUE; + EventObjectSetRegularAnim(eventObject, sprite, GetGoSpeed0AnimId(eventObject->movementDirection)); + eventObject->singleMovementActive = TRUE; sprite->data[1] = 6; return TRUE; } -bool8 sub_808F564(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F564(struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - mapObject->singleMovementActive = FALSE; + eventObject->singleMovementActive = FALSE; sprite->data[1] = 1; } return FALSE; } -bool8 FieldObjectIsTrainerAndCloseToPlayer(struct MapObject *mapObject) +bool8 EventObjectIsTrainerAndCloseToPlayer(struct EventObject *eventObject) { s16 playerX; s16 playerY; @@ -2799,17 +2797,17 @@ bool8 FieldObjectIsTrainerAndCloseToPlayer(struct MapObject *mapObject) { return FALSE; } - if (mapObject->trainerType != 1 && mapObject->trainerType != 3) + if (eventObject->trainerType != 1 && eventObject->trainerType != 3) { return FALSE; } PlayerGetDestCoords(&playerX, &playerY); - objX = mapObject->currentCoords.x; - objY = mapObject->currentCoords.y; - minX = objX - mapObject->trainerRange_berryTreeId; - minY = objY - mapObject->trainerRange_berryTreeId; - maxX = objX + mapObject->trainerRange_berryTreeId; - maxY = objY + mapObject->trainerRange_berryTreeId; + objX = eventObject->currentCoords.x; + objY = eventObject->currentCoords.y; + minX = objX - eventObject->trainerRange_berryTreeId; + minY = objY - eventObject->trainerRange_berryTreeId; + maxX = objX + eventObject->trainerRange_berryTreeId; + maxY = objY + eventObject->trainerRange_berryTreeId; if (minX > playerX || maxX < playerX || minY > playerY || maxY < playerY) { return FALSE; @@ -3008,20 +3006,20 @@ u8 GetNonNorthRunningPastFacingDirection(s16 dx, s16 dy, s16 absdx, s16 absdy) return direction; } -u8 GetRunningPastFacingDirection(struct MapObject *mapObject, u8 movementType) +u8 GetRunningPastFacingDirection(struct EventObject *eventObject, u8 movementType) { s16 dx; s16 dy; s16 absdx; s16 absdy; - if (!FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (!EventObjectIsTrainerAndCloseToPlayer(eventObject)) { return 0; } PlayerGetDestCoords(&dx, &dy); - dx -= mapObject->currentCoords.x; - dy -= mapObject->currentCoords.y; + dx -= eventObject->currentCoords.x; + dy -= eventObject->currentCoords.y; absdx = dx; absdy = dy; if (absdx < 0) @@ -3037,34 +3035,34 @@ u8 GetRunningPastFacingDirection(struct MapObject *mapObject, u8 movementType) field_object_step(LookRandomDirections, gUnknown_0850D740) -bool8 sub_808F988(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F988(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_808F99C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F99C(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_808F9C8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808F9C8(struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_808FA0C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FA0C(struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3072,52 +3070,52 @@ bool8 sub_808FA0C(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_808FA3C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FA3C(struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[4]; u8 direction; memcpy(directions, gUnknown_0850D710, sizeof directions); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_ANY); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_ANY); if (direction == 0) { direction = directions[Random() & 0x03]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyGoNorthOrSouth, gUnknown_0850D754) -bool8 sub_808FAC8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FAC8(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_808FADC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FADC(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_808FB08(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FB08(struct EventObject *eventObject, struct Sprite *sprite) { - if (!FieldObjectExecRegularAnim(mapObject, sprite)) + if (!EventObjectExecRegularAnim(eventObject, sprite)) { return FALSE; } - SetFieldObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); + SetEventObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); sprite->data[1] = 3; return TRUE; } -bool8 sub_808FB44(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FB44(struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite)) + if (RunEventObjectStepTimer(sprite)) { sprite->data[1] = 4; return TRUE; @@ -3125,35 +3123,35 @@ bool8 sub_808FB44(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_808FB64(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FB64(struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[2]; u8 direction; memcpy(directions, gUnknown_0850D770, sizeof directions); direction = directions[Random() & 0x01]; - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 5; - if (npc_block_way__next_tile(mapObject, direction)) + if (npc_block_way__next_tile(eventObject, direction)) { sprite->data[1] = 1; } return TRUE; } -bool8 sub_808FBB0(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FBB0(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->movementDirection)); - mapObject->singleMovementActive = TRUE; + EventObjectSetRegularAnim(eventObject, sprite, GetGoSpeed0AnimId(eventObject->movementDirection)); + eventObject->singleMovementActive = TRUE; sprite->data[1] = 6; return TRUE; } -bool8 sub_808FBE0(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FBE0(struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - mapObject->singleMovementActive = FALSE; + eventObject->singleMovementActive = FALSE; sprite->data[1] = 1; } return FALSE; @@ -3161,34 +3159,34 @@ bool8 sub_808FBE0(struct MapObject *mapObject, struct Sprite *sprite) field_object_step(RandomlyGoEastOrWest, gUnknown_0850D774) -bool8 sub_808FC4C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FC4C(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_808FC60(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FC60(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_808FC8C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FC8C(struct EventObject *eventObject, struct Sprite *sprite) { - if (!FieldObjectExecRegularAnim(mapObject, sprite)) + if (!EventObjectExecRegularAnim(eventObject, sprite)) { return FALSE; } - SetFieldObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); + SetEventObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); sprite->data[1] = 3; return TRUE; } -bool8 sub_808FCC8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FCC8(struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite)) + if (RunEventObjectStepTimer(sprite)) { sprite->data[1] = 4; return TRUE; @@ -3196,35 +3194,35 @@ bool8 sub_808FCC8(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_808FCE8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FCE8(struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[2]; u8 direction; memcpy(directions, gUnknown_0850D790, sizeof directions); direction = directions[Random() & 0x01]; - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 5; - if (npc_block_way__next_tile(mapObject, direction)) + if (npc_block_way__next_tile(eventObject, direction)) { sprite->data[1] = 1; } return TRUE; } -bool8 sub_808FD34(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FD34(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(mapObject->movementDirection)); - mapObject->singleMovementActive = TRUE; + EventObjectSetRegularAnim(eventObject, sprite, GetGoSpeed0AnimId(eventObject->movementDirection)); + eventObject->singleMovementActive = TRUE; sprite->data[1] = 6; return TRUE; } -bool8 sub_808FD64(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FD64(struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - mapObject->singleMovementActive = FALSE; + eventObject->singleMovementActive = FALSE; sprite->data[1] = 1; } return FALSE; @@ -3232,17 +3230,17 @@ bool8 sub_808FD64(struct MapObject *mapObject, struct Sprite *sprite) field_object_step(FaceFixedDirection, gUnknown_0850D794) -bool8 sub_808FDD0(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FDD0(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + npc_reset(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 1; return TRUE; } -bool8 sub_808FDFC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FDFC(struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { sprite->data[1] = 2; return TRUE; @@ -3250,45 +3248,45 @@ bool8 sub_808FDFC(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_808FE1C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FE1C(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->singleMovementActive = FALSE; + eventObject->singleMovementActive = FALSE; return FALSE; } -static bool8 FieldObjectCB2_BerryTree(struct MapObject *mapObject, struct Sprite *sprite); -extern bool8 (*const gUnknown_0850D7A0[])(struct MapObject *mapObject, struct Sprite *sprite); -void FieldObjectCB_BerryTree(struct Sprite *sprite) +static bool8 EventObjectCB2_BerryTree(struct EventObject *eventObject, struct Sprite *sprite); +extern bool8 (*const gUnknown_0850D7A0[])(struct EventObject *eventObject, struct Sprite *sprite); +void EventObjectCB_BerryTree(struct Sprite *sprite) { - struct MapObject *mapObject; + struct EventObject *eventObject; - mapObject = &gMapObjects[sprite->data[0]]; + eventObject = &gEventObjects[sprite->data[0]]; if (!(sprite->data[7] & 0x0001)) { - get_berry_tree_graphics(mapObject, sprite); + get_berry_tree_graphics(eventObject, sprite); sprite->data[7] |= 0x0001; } - FieldObjectStep(mapObject, sprite, FieldObjectCB2_BerryTree); + EventObjectStep(eventObject, sprite, EventObjectCB2_BerryTree); } -static bool8 FieldObjectCB2_BerryTree(struct MapObject *mapObject, struct Sprite *sprite) +static bool8 EventObjectCB2_BerryTree(struct EventObject *eventObject, struct Sprite *sprite) { - return gUnknown_0850D7A0[sprite->data[1]](mapObject, sprite); + return gUnknown_0850D7A0[sprite->data[1]](eventObject, sprite); } -bool8 do_berry_tree_growth_sparkle_1 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 do_berry_tree_growth_sparkle_1 (struct EventObject *eventObject, struct Sprite *sprite) { u8 berryStage; - npc_reset(mapObject, sprite); - mapObject->invisible = TRUE; + npc_reset(eventObject, sprite); + eventObject->invisible = TRUE; sprite->invisible = TRUE; - berryStage = GetStageByBerryTreeId(mapObject->trainerRange_berryTreeId); + berryStage = GetStageByBerryTreeId(eventObject->trainerRange_berryTreeId); if (berryStage == 0) { if (!(sprite->data[7] & 0x0004) && sprite->animNum == 4) { - gFieldEffectArguments[0] = mapObject->currentCoords.x; - gFieldEffectArguments[1] = mapObject->currentCoords.y; + gFieldEffectArguments[0] = eventObject->currentCoords.x; + gFieldEffectArguments[1] = eventObject->currentCoords.y; gFieldEffectArguments[2] = sprite->subpriority - 1; gFieldEffectArguments[3] = sprite->oam.priority; FieldEffectStart(FLDEFF_BERRY_TREE_GROWTH_SPARKLE); @@ -3296,7 +3294,7 @@ bool8 do_berry_tree_growth_sparkle_1 (struct MapObject *mapObject, struct Sprite } return FALSE; } - mapObject->invisible = FALSE; + eventObject->invisible = FALSE; sprite->invisible = FALSE; berryStage --; if (sprite->animNum != berryStage) @@ -3304,15 +3302,15 @@ bool8 do_berry_tree_growth_sparkle_1 (struct MapObject *mapObject, struct Sprite sprite->data[1] = 2; return TRUE; } - get_berry_tree_graphics(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, 0x39); + get_berry_tree_graphics(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, 0x39); sprite->data[1] = 1; return TRUE; } -bool8 sub_808FF48 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FF48 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { sprite->data[1] = 0; return TRUE; @@ -3320,28 +3318,28 @@ bool8 sub_808FF48 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 do_berry_tree_growth_sparkle_2 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 do_berry_tree_growth_sparkle_2 (struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->singleMovementActive = TRUE; + eventObject->singleMovementActive = TRUE; sprite->data[1] = 3; sprite->data[2] = 0; sprite->data[7] |= 0x0002; - gFieldEffectArguments[0] = mapObject->currentCoords.x; - gFieldEffectArguments[1] = mapObject->currentCoords.y; + gFieldEffectArguments[0] = eventObject->currentCoords.x; + gFieldEffectArguments[1] = eventObject->currentCoords.y; gFieldEffectArguments[2] = sprite->subpriority - 1; gFieldEffectArguments[3] = sprite->oam.priority; FieldEffectStart(FLDEFF_BERRY_TREE_GROWTH_SPARKLE); return TRUE; } -bool8 sub_808FFB4 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_808FFB4 (struct EventObject *eventObject, struct Sprite *sprite) { sprite->data[2] ++; - mapObject->invisible = (sprite->data[2] & 0x02) >> 1; + eventObject->invisible = (sprite->data[2] & 0x02) >> 1; sprite->animPaused = TRUE; if (sprite->data[2] > 64) { - get_berry_tree_graphics(mapObject, sprite); + get_berry_tree_graphics(eventObject, sprite); sprite->data[1] = 4; sprite->data[2] = 0; return TRUE; @@ -3349,10 +3347,10 @@ bool8 sub_808FFB4 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090004 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090004 (struct EventObject *eventObject, struct Sprite *sprite) { sprite->data[2] ++; - mapObject->invisible = (sprite->data[2] & 0x02) >> 1; + eventObject->invisible = (sprite->data[2] & 0x02) >> 1; sprite->animPaused = TRUE; if (sprite->data[2] > 64) { @@ -3365,34 +3363,34 @@ bool8 sub_8090004 (struct MapObject *mapObject, struct Sprite *sprite) field_object_step(RandomlyLookNorthOrSouth, gUnknown_0850D7B4) -bool8 sub_8090094 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090094 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_80900A8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80900A8 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_80900D4 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80900D4 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090118 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090118 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3400,52 +3398,52 @@ bool8 sub_8090118 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090148 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090148 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[2]; u8 direction; memcpy(directions, gUnknown_0850D770, sizeof gUnknown_0850D770); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_SOUTH); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_NORTH_SOUTH); if (direction == 0) { direction = directions[Random() & 0x01]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookEastOrWest, gUnknown_0850D7C8) -bool8 sub_80901D4 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80901D4 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_80901E8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80901E8 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090214 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090214 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysMedium[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090258 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090258 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3453,52 +3451,52 @@ bool8 sub_8090258 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090288 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090288 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[2]; u8 direction; memcpy(directions, gUnknown_0850D790, sizeof gUnknown_0850D790); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_EAST_WEST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_EAST_WEST); if (direction == 0) { direction = directions[Random() & 0x01]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookNorthOrWest, gUnknown_0850D7DC) -bool8 sub_8090314 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090314 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090328 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090328 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090354 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090354 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090398 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090398 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3506,52 +3504,52 @@ bool8 sub_8090398 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_80903C8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80903C8 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[2]; u8 direction; memcpy(directions, gUnknown_0850D7F0, sizeof gUnknown_0850D7F0); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_WEST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_NORTH_WEST); if (direction == 0) { direction = directions[Random() & 0x01]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookNorthOrEast, gUnknown_0850D7F4) -bool8 sub_8090454 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090454 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090468 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090468 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090494 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090494 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_80904D8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80904D8 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3559,52 +3557,52 @@ bool8 sub_80904D8 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090508 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090508 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[2]; u8 direction; memcpy(directions, gUnknown_0850D808, sizeof gUnknown_0850D808); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_EAST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_NORTH_EAST); if (direction == 0) { direction = directions[Random() & 0x01]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookSouthOrWest, gUnknown_0850D80C) -bool8 sub_8090594 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090594 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_80905A8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80905A8 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_80905D4 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80905D4 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090618 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090618 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3612,52 +3610,52 @@ bool8 sub_8090618 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090648 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090648 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[2]; u8 direction; memcpy(directions, gUnknown_0850D820, sizeof gUnknown_0850D820); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_SOUTH_WEST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_SOUTH_WEST); if (direction == 0) { direction = directions[Random() & 0x01]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookSouthOrEast, gUnknown_0850D824) -bool8 sub_80906D4 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80906D4 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_80906E8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80906E8 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090714 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090714 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090758 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090758 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3665,52 +3663,52 @@ bool8 sub_8090758 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090788 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090788 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[2]; u8 direction; memcpy(directions, gUnknown_0850D838, sizeof gUnknown_0850D838); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_SOUTH_EAST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_SOUTH_EAST); if (direction == 0) { direction = directions[Random() & 0x01]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookNorthOrSouthOrWest, gUnknown_0850D83C) -bool8 sub_8090814 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090814 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090828 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090828 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090854 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090854 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090898 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090898 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3718,52 +3716,52 @@ bool8 sub_8090898 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_80908C8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80908C8 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[4]; u8 direction; memcpy(directions, gUnknown_0850D850, sizeof gUnknown_0850D850); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_SOUTH_WEST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_NORTH_SOUTH_WEST); if (direction == 0) { direction = directions[Random() & 0x03]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookNorthOrSouthOrEast, gUnknown_0850D854) -bool8 sub_8090954 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090954 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090968 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090968 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090994 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090994 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_80909D8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80909D8 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3771,52 +3769,52 @@ bool8 sub_80909D8 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090A08 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090A08 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[4]; u8 direction; memcpy(directions, gUnknown_0850D868, sizeof gUnknown_0850D868); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_SOUTH_EAST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_NORTH_SOUTH_EAST); if (direction == 0) { direction = directions[Random() & 0x03]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookNorthOrEastOrWest, gUnknown_0850D86C) -bool8 sub_8090A94 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090A94 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090AA8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090AA8 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090AD4 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090AD4 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090B18 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090B18 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3824,52 +3822,52 @@ bool8 sub_8090B18 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090B48 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090B48 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[4]; u8 direction; memcpy(directions, gUnknown_0850D880, sizeof gUnknown_0850D880); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_NORTH_EAST_WEST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_NORTH_EAST_WEST); if (direction == 0) { direction = directions[Random() & 0x03]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(RandomlyLookSouthOrEastOrWest, gUnknown_0850D884) -bool8 sub_8090BD4 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090BD4 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090BE8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090BE8 (struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090C14 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090C14 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); - mapObject->singleMovementActive = FALSE; + SetEventObjectStepTimer(sprite, gMovementDelaysShort[Random() & 0x03]); + eventObject->singleMovementActive = FALSE; sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090C58 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090C58 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 4; return TRUE; @@ -3877,215 +3875,215 @@ bool8 sub_8090C58 (struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_8090C88 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090C88 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[4]; u8 direction; memcpy(directions, gUnknown_0850D898, sizeof gUnknown_0850D898); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_SOUTH_EAST_WEST); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_SOUTH_EAST_WEST); if (direction == 0) { direction = directions[Random() & 0x03]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 1; return TRUE; } field_object_step(LookAroundCounterclockwise, gUnknown_0850D89C) -bool8 sub_8090D14 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090D14 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + npc_reset(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090D40 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090D40 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, 48); + SetEventObjectStepTimer(sprite, 48); sprite->data[1] = 2; } return FALSE; } -bool8 sub_8090D64 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090D64 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090D90 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090D90 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[5]; u8 direction; memcpy(directions, gUnknown_0850D8AC, sizeof gUnknown_0850D8AC); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_ANY); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_ANY); if (direction == 0) { - direction = directions[mapObject->facingDirection]; + direction = directions[eventObject->facingDirection]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 0; return TRUE; } field_object_step(LookAroundClockwise, gUnknown_0850D8B4) -bool8 sub_8090E18 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090E18 (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); + npc_reset(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090E44 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090E44 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - SetFieldObjectStepTimer(sprite, 48); + SetEventObjectStepTimer(sprite, 48); sprite->data[1] = 2; } return FALSE; } -bool8 sub_8090E68 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090E68 (struct EventObject *eventObject, struct Sprite *sprite) { - if (RunFieldObjectStepTimer(sprite) || FieldObjectIsTrainerAndCloseToPlayer(mapObject)) + if (RunEventObjectStepTimer(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) { sprite->data[1] = 3; } return FALSE; } -bool8 sub_8090E94 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090E94 (struct EventObject *eventObject, struct Sprite *sprite) { u8 directions[5]; u8 direction; memcpy(directions, gUnknown_0850D8C4, sizeof gUnknown_0850D8C4); - direction = GetRunningPastFacingDirection(mapObject, RUNFOLLOW_ANY); + direction = GetRunningPastFacingDirection(eventObject, RUNFOLLOW_ANY); if (direction == 0) { - direction = directions[mapObject->facingDirection]; + direction = directions[eventObject->facingDirection]; } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 0; return TRUE; } field_object_step(AlternatelyGoInOppositeDirections, gUnknown_0850D8CC) -bool8 sub_8090F1C (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090F1C (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 sub_8090F30 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090F30 (struct EventObject *eventObject, struct Sprite *sprite) { u8 direction; - direction = gInitialMovementTypeFacingDirections[mapObject->movementType]; - if (mapObject->directionSequenceIndex) + direction = gInitialMovementTypeFacingDirections[eventObject->movementType]; + if (eventObject->directionSequenceIndex) { direction = GetOppositeDirection(direction); } - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[1] = 2; return TRUE; } -bool8 sub_8090F68 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8090F68 (struct EventObject *eventObject, struct Sprite *sprite) { bool8 blockingWay; u8 animId; - if (mapObject->directionSequenceIndex && mapObject->initialCoords.x == mapObject->currentCoords.x && mapObject->initialCoords.y == mapObject->currentCoords.y) + if (eventObject->directionSequenceIndex && eventObject->initialCoords.x == eventObject->currentCoords.x && eventObject->initialCoords.y == eventObject->currentCoords.y) { - mapObject->directionSequenceIndex = 0; - FieldObjectSetDirection(mapObject, GetOppositeDirection(mapObject->movementDirection)); + eventObject->directionSequenceIndex = 0; + EventObjectSetDirection(eventObject, GetOppositeDirection(eventObject->movementDirection)); } - blockingWay = npc_block_way__next_tile(mapObject, mapObject->movementDirection); - animId = GetGoSpeed0AnimId(mapObject->movementDirection); + blockingWay = npc_block_way__next_tile(eventObject, eventObject->movementDirection); + animId = GetGoSpeed0AnimId(eventObject->movementDirection); if (blockingWay == TRUE) { - mapObject->directionSequenceIndex ++; - FieldObjectSetDirection(mapObject, GetOppositeDirection(mapObject->movementDirection)); - animId = GetGoSpeed0AnimId(mapObject->movementDirection); - blockingWay = npc_block_way__next_tile(mapObject, mapObject->movementDirection); + eventObject->directionSequenceIndex ++; + EventObjectSetDirection(eventObject, GetOppositeDirection(eventObject->movementDirection)); + animId = GetGoSpeed0AnimId(eventObject->movementDirection); + blockingWay = npc_block_way__next_tile(eventObject, eventObject->movementDirection); } if (blockingWay) { - animId = GetStepInPlaceDelay16AnimId(mapObject->facingDirection); + animId = GetStepInPlaceDelay16AnimId(eventObject->facingDirection); } - FieldObjectSetRegularAnim(mapObject, sprite, animId); - mapObject->singleMovementActive = TRUE; + EventObjectSetRegularAnim(eventObject, sprite, animId); + eventObject->singleMovementActive = TRUE; sprite->data[1] = 3; return TRUE; } -bool8 sub_8091020 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8091020 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - mapObject->singleMovementActive = FALSE; + eventObject->singleMovementActive = FALSE; sprite->data[1] = 1; } return FALSE; } -bool8 sub_8091048(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8091048(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MoveFieldObjectInNextDirectionInSequence(struct MapObject *mapObject, struct Sprite *sprite, u8 *route) +bool8 MoveEventObjectInNextDirectionInSequence(struct EventObject *eventObject, struct Sprite *sprite, u8 *route) { u8 blockingWay; u8 animId; - if (mapObject->directionSequenceIndex == 3 && mapObject->initialCoords.x == mapObject->currentCoords.x && mapObject->initialCoords.y == mapObject->currentCoords.y) + if (eventObject->directionSequenceIndex == 3 && eventObject->initialCoords.x == eventObject->currentCoords.x && eventObject->initialCoords.y == eventObject->currentCoords.y) { - mapObject->directionSequenceIndex = 0; + eventObject->directionSequenceIndex = 0; } - FieldObjectSetDirection(mapObject, route[mapObject->directionSequenceIndex]); - animId = GetGoSpeed0AnimId(mapObject->movementDirection); - blockingWay = npc_block_way__next_tile(mapObject, mapObject->movementDirection); + EventObjectSetDirection(eventObject, route[eventObject->directionSequenceIndex]); + animId = GetGoSpeed0AnimId(eventObject->movementDirection); + blockingWay = npc_block_way__next_tile(eventObject, eventObject->movementDirection); if (blockingWay == TRUE) { - mapObject->directionSequenceIndex ++; - FieldObjectSetDirection(mapObject, route[mapObject->directionSequenceIndex]); - animId = GetGoSpeed0AnimId(mapObject->movementDirection); - blockingWay = npc_block_way__next_tile(mapObject, mapObject->movementDirection); + eventObject->directionSequenceIndex ++; + EventObjectSetDirection(eventObject, route[eventObject->directionSequenceIndex]); + animId = GetGoSpeed0AnimId(eventObject->movementDirection); + blockingWay = npc_block_way__next_tile(eventObject, eventObject->movementDirection); } if (blockingWay) { - animId = GetStepInPlaceDelay16AnimId(mapObject->facingDirection); + animId = GetStepInPlaceDelay16AnimId(eventObject->facingDirection); } - FieldObjectSetRegularAnim(mapObject, sprite, animId); - mapObject->singleMovementActive = TRUE; + EventObjectSetRegularAnim(eventObject, sprite, animId); + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 sub_8091110(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8091110(struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - mapObject->singleMovementActive = FALSE; + eventObject->singleMovementActive = FALSE; sprite->data[1] = 1; } return FALSE; @@ -4118,271 +4116,271 @@ field_object_path(24, gUnknown_0850DA48, sub_8091E10, gUnknown_0850DA54, 2, x) field_object_step(CopyPlayer1, gUnknown_0850DA58) -bool8 mss_npc_reset_oampriv3_1_unk2_unk3(struct MapObject *mapObject, struct Sprite *sprite) +bool8 mss_npc_reset_oampriv3_1_unk2_unk3(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - if (mapObject->directionSequenceIndex == 0) + npc_reset(eventObject, sprite); + if (eventObject->directionSequenceIndex == 0) { - mapObject->directionSequenceIndex = player_get_direction_lower_nybble(); + eventObject->directionSequenceIndex = player_get_direction_lower_nybble(); } sprite->data[1] = 1; return TRUE; } -bool8 sub_8091EC0(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8091EC0(struct EventObject *eventObject, struct Sprite *sprite) { - if (gMapObjects[gPlayerAvatar.mapObjectId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == 2) + if (gEventObjects[gPlayerAvatar.eventObjectId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == 2) { return FALSE; } - return gUnknown_0850DA64[player_get_x22()](mapObject, sprite, player_get_direction_upper_nybble(), NULL); + return gUnknown_0850DA64[player_get_x22()](eventObject, sprite, player_get_direction_upper_nybble(), NULL); } -bool8 sub_8091F20(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8091F20(struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { - mapObject->singleMovementActive = FALSE; + eventObject->singleMovementActive = FALSE; sprite->data[1] = 1; } return FALSE; } -bool8 sub_8091F48(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 sub_8091F48(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { return FALSE; } -bool8 sub_8091F4C(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 sub_8091F4C(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, playerDirection))); - mapObject->singleMovementActive = TRUE; + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, playerDirection))); + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 sub_8091F94(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 sub_8091F94(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - if (FieldObjectIsFarawayIslandMew(mapObject)) + if (EventObjectIsFarawayIslandMew(eventObject)) { direction = sub_81D427C(); if (direction == 0) { direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, direction); - FieldObjectMoveDestCoords(mapObject, direction, &x, &y); - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); - mapObject->singleMovementActive = TRUE; + direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); + EventObjectMoveDestCoords(eventObject, direction, &x, &y); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(direction)); + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } } else { - direction = state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, direction); + direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); } - FieldObjectMoveDestCoords(mapObject, direction, &x, &y); - FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed0AnimId(direction)); - if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + EventObjectMoveDestCoords(eventObject, direction, &x, &y); + EventObjectSetRegularAnim(eventObject, sprite, GetGoSpeed0AnimId(direction)); + if (npc_block_way(eventObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(direction)); } - mapObject->singleMovementActive = TRUE; + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 sub_80920A4(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 sub_80920A4(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, direction); - FieldObjectMoveDestCoords(mapObject, direction, &x, &y); - FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed1AnimId(direction)); - if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); + EventObjectMoveDestCoords(eventObject, direction, &x, &y); + EventObjectSetRegularAnim(eventObject, sprite, GetGoSpeed1AnimId(direction)); + if (npc_block_way(eventObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(direction)); } - mapObject->singleMovementActive = TRUE; + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 sub_809215C(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 sub_809215C(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, direction); - FieldObjectMoveDestCoords(mapObject, direction, &x, &y); - FieldObjectSetRegularAnim(mapObject, sprite, GetGoSpeed3AnimId(direction)); - if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); + EventObjectMoveDestCoords(eventObject, direction, &x, &y); + EventObjectSetRegularAnim(eventObject, sprite, GetGoSpeed3AnimId(direction)); + if (npc_block_way(eventObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(direction)); } - mapObject->singleMovementActive = TRUE; + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 sub_8092214(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 sub_8092214(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, direction); - FieldObjectMoveDestCoords(mapObject, direction, &x, &y); - FieldObjectSetRegularAnim(mapObject, sprite, sub_8093438(direction)); - if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); + EventObjectMoveDestCoords(eventObject, direction, &x, &y); + EventObjectSetRegularAnim(eventObject, sprite, sub_8093438(direction)); + if (npc_block_way(eventObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(direction)); } - mapObject->singleMovementActive = TRUE; + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 cph_IM_DIFFERENT(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 cph_IM_DIFFERENT(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { u32 direction; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, direction); - FieldObjectSetRegularAnim(mapObject, sprite, sub_80934BC(direction)); - mapObject->singleMovementActive = TRUE; + direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); + EventObjectSetRegularAnim(eventObject, sprite, sub_80934BC(direction)); + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 sub_8092314(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 sub_8092314(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, direction); - FieldObjectMoveDestCoords(mapObject, direction, &x, &y); - FieldObjectSetRegularAnim(mapObject, sprite, sub_8093514(direction)); - if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); + EventObjectMoveDestCoords(eventObject, direction, &x, &y); + EventObjectSetRegularAnim(eventObject, sprite, sub_8093514(direction)); + if (npc_block_way(eventObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(direction)); } - mapObject->singleMovementActive = TRUE; + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 oac_hopping(struct MapObject *mapObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) +bool8 oac_hopping(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCB(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[mapObject->movementType], mapObject->directionSequenceIndex, direction); - x = mapObject->currentCoords.x; - y = mapObject->currentCoords.y; + direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); + x = eventObject->currentCoords.x; + y = eventObject->currentCoords.y; sub_8092F88(direction, &x, &y, 2, 2); - FieldObjectSetRegularAnim(mapObject, sprite, GetJumpLedgeAnimId(direction)); - if (npc_block_way(mapObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) + EventObjectSetRegularAnim(eventObject, sprite, GetJumpLedgeAnimId(direction)); + if (npc_block_way(eventObject, x, y, direction) || (tileCB != NULL && !tileCB(MapGridGetMetatileBehaviorAt(x, y)))) { - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(direction)); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(direction)); } - mapObject->singleMovementActive = TRUE; + eventObject->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } field_object_step(CopyPlayer2, gUnknown_0850DA90) -bool8 mss_08062EA4(struct MapObject *mapObject, struct Sprite *sprite) +bool8 mss_08062EA4(struct EventObject *eventObject, struct Sprite *sprite) { - if (gMapObjects[gPlayerAvatar.mapObjectId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == 2) + if (gEventObjects[gPlayerAvatar.eventObjectId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == 2) { return FALSE; } - return gUnknown_0850DA64[player_get_x22()](mapObject, sprite, player_get_direction_upper_nybble(), MetatileBehavior_IsPokeGrass); + return gUnknown_0850DA64[player_get_x22()](eventObject, sprite, player_get_direction_upper_nybble(), MetatileBehavior_IsPokeGrass); } -bool8 sub_80925AC(struct MapObject *, struct Sprite *); +bool8 sub_80925AC(struct EventObject *, struct Sprite *); -void FieldObjectCB_TreeDisguise(struct Sprite *sprite) +void EventObjectCB_TreeDisguise(struct Sprite *sprite) { - struct MapObject *mapObject; + struct EventObject *eventObject; - mapObject = &gMapObjects[sprite->data[0]]; - if (mapObject->directionSequenceIndex == 0 || (mapObject->directionSequenceIndex == 1 && !sprite->data[7])) + eventObject = &gEventObjects[sprite->data[0]]; + if (eventObject->directionSequenceIndex == 0 || (eventObject->directionSequenceIndex == 1 && !sprite->data[7])) { - FieldObjectGetLocalIdAndMap(mapObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); - mapObject->fieldEffectSpriteId = FieldEffectStart(FLDEFF_TREE_DISGUISE); - mapObject->directionSequenceIndex = 1; + EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + eventObject->fieldEffectSpriteId = FieldEffectStart(FLDEFF_TREE_DISGUISE); + eventObject->directionSequenceIndex = 1; sprite->data[7] ++; } - FieldObjectStep(&gMapObjects[sprite->data[0]], sprite, sub_80925AC); + EventObjectStep(&gEventObjects[sprite->data[0]], sprite, sub_80925AC); } -bool8 sub_80925AC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80925AC(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); return FALSE; } -void FieldObjectCB_MountainDisguise(struct Sprite *sprite) +void EventObjectCB_MountainDisguise(struct Sprite *sprite) { - struct MapObject *mapObject; + struct EventObject *eventObject; - mapObject = &gMapObjects[sprite->data[0]]; - if (mapObject->directionSequenceIndex == 0 || (mapObject->directionSequenceIndex == 1 && !sprite->data[7])) + eventObject = &gEventObjects[sprite->data[0]]; + if (eventObject->directionSequenceIndex == 0 || (eventObject->directionSequenceIndex == 1 && !sprite->data[7])) { - FieldObjectGetLocalIdAndMap(mapObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); - mapObject->fieldEffectSpriteId = FieldEffectStart(FLDEFF_MOUNTAIN_DISGUISE); - mapObject->directionSequenceIndex = 1; + EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + eventObject->fieldEffectSpriteId = FieldEffectStart(FLDEFF_MOUNTAIN_DISGUISE); + eventObject->directionSequenceIndex = 1; sprite->data[7] ++; } - FieldObjectStep(&gMapObjects[sprite->data[0]], sprite, sub_80925AC); + EventObjectStep(&gEventObjects[sprite->data[0]], sprite, sub_80925AC); } -extern bool8 (*const gUnknown_0850DA9C[])(struct MapObject *, struct Sprite *); -bool8 sub_809268C(struct MapObject *, struct Sprite *); +extern bool8 (*const gUnknown_0850DA9C[])(struct EventObject *, struct Sprite *); +bool8 sub_809268C(struct EventObject *, struct Sprite *); -void FieldObjectCB_Hidden1(struct Sprite *sprite) +void EventObjectCB_Hidden1(struct Sprite *sprite) { if (!sprite->data[7]) { - gMapObjects[sprite->data[0]].fixedPriority = TRUE; + gEventObjects[sprite->data[0]].fixedPriority = TRUE; sprite->subspriteMode = 2; sprite->oam.priority = 3; sprite->data[7] ++; } - FieldObjectStep(&gMapObjects[sprite->data[0]], sprite, sub_809268C); + EventObjectStep(&gEventObjects[sprite->data[0]], sprite, sub_809268C); } -bool8 sub_809268C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_809268C(struct EventObject *eventObject, struct Sprite *sprite) { - return gUnknown_0850DA9C[sprite->data[1]](mapObject, sprite); + return gUnknown_0850DA9C[sprite->data[1]](eventObject, sprite); } -bool8 sub_80926AC (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80926AC (struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); + npc_reset(eventObject, sprite); return FALSE; } -bool8 sub_80926B8 (struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80926B8 (struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { sprite->data[1] = 0; } @@ -4391,57 +4389,57 @@ bool8 sub_80926B8 (struct MapObject *mapObject, struct Sprite *sprite) field_object_step(WalkInPlace1, gUnknown_0850DAA0) -bool8 sub_8092718(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8092718(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, GetStepInPlaceDelay16AnimId(mapObject->facingDirection)); + npc_reset(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, GetStepInPlaceDelay16AnimId(eventObject->facingDirection)); sprite->data[1] = 1; return TRUE; } field_object_step(WalkInPlace4, gUnknown_0850DAA8) -bool8 sub_8092788(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8092788(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, GetStepInPlaceDelay32AnimId(mapObject->facingDirection)); + npc_reset(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, GetStepInPlaceDelay32AnimId(eventObject->facingDirection)); sprite->data[1] = 1; return TRUE; } field_object_step(WalkInPlace2, gUnknown_0850DAB0) -bool8 sub_80927F8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80927F8(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, GetStepInPlaceDelay8AnimId(mapObject->facingDirection)); + npc_reset(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, GetStepInPlaceDelay8AnimId(eventObject->facingDirection)); sprite->data[1] = 1; return TRUE; } field_object_step(WalkInPlace3, gUnknown_0850DAB8) -bool8 sub_8092868(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8092868(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, GetStepInPlaceDelay4AnimId(mapObject->facingDirection)); + npc_reset(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, GetStepInPlaceDelay4AnimId(eventObject->facingDirection)); sprite->data[1] = 1; return TRUE; } field_object_step(Hidden2, gUnknown_0850DAC0) -bool8 sub_80928D8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80928D8(struct EventObject *eventObject, struct Sprite *sprite) { - npc_reset(mapObject, sprite); - FieldObjectSetRegularAnim(mapObject, sprite, GetFaceDirectionAnimId(mapObject->facingDirection)); - mapObject->invisible = TRUE; + npc_reset(eventObject, sprite); + EventObjectSetRegularAnim(eventObject, sprite, GetFaceDirectionAnimId(eventObject->facingDirection)); + eventObject->invisible = TRUE; sprite->data[1] = 1; return TRUE; } -bool8 sub_809290C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_809290C(struct EventObject *eventObject, struct Sprite *sprite) { - if (FieldObjectExecRegularAnim(mapObject, sprite)) + if (EventObjectExecRegularAnim(eventObject, sprite)) { sprite->data[1] = 2; return TRUE; @@ -4449,18 +4447,18 @@ bool8 sub_809290C(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_809292C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_809292C(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->singleMovementActive = FALSE; + eventObject->singleMovementActive = FALSE; return FALSE; } -static void npc_reset(struct MapObject *mapObject, struct Sprite *sprite) +static void npc_reset(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->singleMovementActive = FALSE; - mapObject->heldMovementActive = FALSE; - mapObject->heldMovementFinished = FALSE; - mapObject->movementActionId = 0xFF; + eventObject->singleMovementActive = FALSE; + eventObject->heldMovementActive = FALSE; + eventObject->heldMovementFinished = FALSE; + eventObject->movementActionId = 0xFF; sprite->data[1] = 0; } @@ -4470,7 +4468,7 @@ u8 name(u8 direction)\ return table[direction];\ } -dirn2anim(FieldObjectDirectionToImageAnimId, gUnknown_0850DACC) +dirn2anim(EventObjectDirectionToImageAnimId, gUnknown_0850DACC) dirn2anim(get_go_image_anim_num, gUnknown_0850DAD5) dirn2anim(get_go_fast_image_anim_num, gUnknown_0850DADE) dirn2anim(get_go_faster_image_anim_num, gUnknown_0850DAE7) @@ -4500,11 +4498,11 @@ static const struct UnkStruct_085094AC *sub_8092A4C(const union AnimCmd *const * return NULL; } -void npc_apply_anim_looping(struct MapObject *mapObject, struct Sprite *sprite, u8 animNum) +void npc_apply_anim_looping(struct EventObject *eventObject, struct Sprite *sprite, u8 animNum) { const struct UnkStruct_085094AC *unk85094AC; - if (!mapObject->inanimate) + if (!eventObject->inanimate) { sprite->animNum = animNum; unk85094AC = sub_8092A4C(sprite->anims); @@ -4523,11 +4521,11 @@ void npc_apply_anim_looping(struct MapObject *mapObject, struct Sprite *sprite, } } -void obj_npc_animation_step(struct MapObject *mapObject, struct Sprite *sprite, u8 animNum) +void obj_npc_animation_step(struct EventObject *eventObject, struct Sprite *sprite, u8 animNum) { const struct UnkStruct_085094AC *unk85094AC; - if (!mapObject->inanimate) + if (!eventObject->inanimate) { u8 animPos; @@ -4564,100 +4562,100 @@ u8 sub_8092AF8(s16 x1, s16 y1, s16 x2, s16 y2) return DIR_SOUTH; } -void npc_set_running_behaviour_etc(struct MapObject *mapObject, u8 movementType) +void npc_set_running_behaviour_etc(struct EventObject *eventObject, u8 movementType) { - mapObject->movementType = movementType; - mapObject->directionSequenceIndex = 0; - mapObject->playerCopyableMovement = 0; - gSprites[mapObject->spriteId].callback = gUnknown_08505438[movementType]; - gSprites[mapObject->spriteId].data[1] = 0; + eventObject->movementType = movementType; + eventObject->directionSequenceIndex = 0; + eventObject->playerCopyableMovement = 0; + gSprites[eventObject->spriteId].callback = gUnknown_08505438[movementType]; + gSprites[eventObject->spriteId].data[1] = 0; } dirn2anim(npc_running_behaviour_by_direction, gUnknown_0850DB53) -u8 npc_block_way__next_tile(struct MapObject *mapObject, u8 direction) +u8 npc_block_way__next_tile(struct EventObject *eventObject, u8 direction) { s16 x; s16 y; - x = mapObject->currentCoords.x; - y = mapObject->currentCoords.y; + x = eventObject->currentCoords.x; + y = eventObject->currentCoords.y; MoveCoords(direction, &x, &y); - return npc_block_way(mapObject, x, y, direction); + return npc_block_way(eventObject, x, y, direction); } -u8 npc_block_way(struct MapObject *mapObject, s16 x, s16 y, u32 dirn) +u8 npc_block_way(struct EventObject *eventObject, s16 x, s16 y, u32 dirn) { u8 direction; direction = dirn; - if (IsCoordOutsideFieldObjectMovementRect(mapObject, x, y)) + if (IsCoordOutsideEventObjectMovementRect(eventObject, x, y)) { return 1; } - if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(mapObject, x, y, direction)) + if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(eventObject, x, y, direction)) { return 2; } - if (mapObject->trackedByCamera && !CanCameraMoveInDirection(direction)) + if (eventObject->trackedByCamera && !CanCameraMoveInDirection(direction)) { return 2; } - if (IsZCoordMismatchAt(mapObject->currentElevation, x, y)) + if (IsZCoordMismatchAt(eventObject->currentElevation, x, y)) { return 3; } - if (CheckForCollisionBetweenFieldObjects(mapObject, x, y)) + if (CheckForCollisionBetweenEventObjects(eventObject, x, y)) { return 4; } return 0; } -u8 sub_8092C8C(struct MapObject *mapObject, s16 x, s16 y, u8 direction) +u8 sub_8092C8C(struct EventObject *eventObject, s16 x, s16 y, u8 direction) { u8 retval; retval = 0x00; - if (IsCoordOutsideFieldObjectMovementRect(mapObject, x, y)) + if (IsCoordOutsideEventObjectMovementRect(eventObject, x, y)) { retval |= 1; } - if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(mapObject, x, y, direction) || (mapObject->trackedByCamera && !CanCameraMoveInDirection(direction))) + if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(eventObject, x, y, direction) || (eventObject->trackedByCamera && !CanCameraMoveInDirection(direction))) { retval |= 2; } - if (IsZCoordMismatchAt(mapObject->currentElevation, x, y)) + if (IsZCoordMismatchAt(eventObject->currentElevation, x, y)) { retval |= 4; } - if (CheckForCollisionBetweenFieldObjects(mapObject, x, y)) + if (CheckForCollisionBetweenEventObjects(eventObject, x, y)) { retval |= 8; } return retval; } -static bool8 IsCoordOutsideFieldObjectMovementRect(struct MapObject *mapObject, s16 x, s16 y) +static bool8 IsCoordOutsideEventObjectMovementRect(struct EventObject *eventObject, s16 x, s16 y) { s16 left; s16 right; s16 top; s16 bottom; - if (mapObject->range.as_nybbles.x != 0) + if (eventObject->range.as_nybbles.x != 0) { - left = mapObject->initialCoords.x - mapObject->range.as_nybbles.x; - right = mapObject->initialCoords.x + mapObject->range.as_nybbles.x; + left = eventObject->initialCoords.x - eventObject->range.as_nybbles.x; + right = eventObject->initialCoords.x + eventObject->range.as_nybbles.x; if (left > x || right < x) { return TRUE; } } - if (mapObject->range.as_nybbles.y != 0) + if (eventObject->range.as_nybbles.y != 0) { - top = mapObject->initialCoords.y - mapObject->range.as_nybbles.y; - bottom = mapObject->initialCoords.y + mapObject->range.as_nybbles.y; + top = eventObject->initialCoords.y - eventObject->range.as_nybbles.y; + bottom = eventObject->initialCoords.y + eventObject->range.as_nybbles.y; if (top > y || bottom < y) { return TRUE; @@ -4666,28 +4664,28 @@ static bool8 IsCoordOutsideFieldObjectMovementRect(struct MapObject *mapObject, return FALSE; } -static bool8 IsMetatileDirectionallyImpassable(struct MapObject *mapObject, s16 x, s16 y, u8 direction) +static bool8 IsMetatileDirectionallyImpassable(struct EventObject *eventObject, s16 x, s16 y, u8 direction) { - if (gOppositeDirectionBlockedMetatileFuncs[direction - 1](mapObject->currentMetatileBehavior) || gDirectionBlockedMetatileFuncs[direction - 1](MapGridGetMetatileBehaviorAt(x, y))) + if (gOppositeDirectionBlockedMetatileFuncs[direction - 1](eventObject->currentMetatileBehavior) || gDirectionBlockedMetatileFuncs[direction - 1](MapGridGetMetatileBehaviorAt(x, y))) { return TRUE; } return FALSE; } -static bool8 CheckForCollisionBetweenFieldObjects(struct MapObject *mapObject, s16 x, s16 y) +static bool8 CheckForCollisionBetweenEventObjects(struct EventObject *eventObject, s16 x, s16 y) { u8 i; - struct MapObject *curObject; + struct EventObject *curObject; - for (i = 0; i < NUM_FIELD_OBJECTS; i ++) + for (i = 0; i < NUM_EVENT_OBJECTS; i ++) { - curObject = &gMapObjects[i]; - if (curObject->active && curObject != mapObject) + curObject = &gEventObjects[i]; + if (curObject->active && curObject != eventObject) { if ((curObject->currentCoords.x == x && curObject->currentCoords.y == y) || (curObject->previousCoords.x == x && curObject->previousCoords.y == y)) { - if (AreZCoordsCompatible(mapObject->currentElevation, curObject->currentElevation)) + if (AreZCoordsCompatible(eventObject->currentElevation, curObject->currentElevation)) { return TRUE; } @@ -4699,9 +4697,9 @@ static bool8 CheckForCollisionBetweenFieldObjects(struct MapObject *mapObject, s bool8 sub_8092E9C(u8 localId, u8 mapNum, u8 mapGroup) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId) && gSprites[gMapObjects[mapObjectId].spriteId].data[7] & 0x02) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId) && gSprites[gEventObjects[eventObjectId].spriteId].data[7] & 0x02) { return TRUE; } @@ -4710,11 +4708,11 @@ bool8 sub_8092E9C(u8 localId, u8 mapNum, u8 mapGroup) void sub_8092EF0(u8 localId, u8 mapNum, u8 mapGroup) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) { - gSprites[gMapObjects[mapObjectId].spriteId].data[7] |= 0x04; + gSprites[gEventObjects[eventObjectId].spriteId].data[7] |= 0x04; } } @@ -4803,7 +4801,7 @@ void sub_80930E0(s16 *x, s16 *y, s16 dx, s16 dy) *y += dy; } -static void GetFieldObjectMovingCameraOffset(s16 *x, s16 *y) +static void GetEventObjectMovingCameraOffset(s16 *x, s16 *y) { *x = 0; *y = 0; @@ -4825,120 +4823,120 @@ static void GetFieldObjectMovingCameraOffset(s16 *x, s16 *y) } } -void FieldObjectMoveDestCoords(struct MapObject *mapObject, u32 dirn, s16 *x, s16 *y) +void EventObjectMoveDestCoords(struct EventObject *eventObject, u32 dirn, s16 *x, s16 *y) { u8 direction; direction = dirn; - *x = mapObject->currentCoords.x; - *y = mapObject->currentCoords.y; + *x = eventObject->currentCoords.x; + *y = eventObject->currentCoords.y; MoveCoords(direction, x, y); } // file boundary? -bool8 FieldObjectIsSpecialAnimOrDirectionSequenceAnimActive(struct MapObject *mapObject) +bool8 EventObjectIsSpecialAnimOrDirectionSequenceAnimActive(struct EventObject *eventObject) { - if (mapObject->singleMovementActive || mapObject->heldMovementActive) + if (eventObject->singleMovementActive || eventObject->heldMovementActive) { return TRUE; } return FALSE; } -bool8 FieldObjectIsSpecialAnimActive(struct MapObject *mapObject) +bool8 EventObjectIsSpecialAnimActive(struct EventObject *eventObject) { - if (mapObject->heldMovementActive && mapObject->movementActionId != 0xFF) + if (eventObject->heldMovementActive && eventObject->movementActionId != 0xFF) { return TRUE; } return FALSE; } -bool8 FieldObjectSetSpecialAnim(struct MapObject *mapObject, u8 specialAnimId) +bool8 EventObjectSetSpecialAnim(struct EventObject *eventObject, u8 specialAnimId) { - if (FieldObjectIsSpecialAnimOrDirectionSequenceAnimActive(mapObject)) + if (EventObjectIsSpecialAnimOrDirectionSequenceAnimActive(eventObject)) { return TRUE; } - npc_sync_anim_pause_bits(mapObject); - mapObject->movementActionId = specialAnimId; - mapObject->heldMovementActive = TRUE; - mapObject->heldMovementFinished = FALSE; - gSprites[mapObject->spriteId].data[2] = 0; + npc_sync_anim_pause_bits(eventObject); + eventObject->movementActionId = specialAnimId; + eventObject->heldMovementActive = TRUE; + eventObject->heldMovementFinished = FALSE; + gSprites[eventObject->spriteId].data[2] = 0; return FALSE; } -void FieldObjectForceSetSpecialAnim(struct MapObject *mapObject, u8 specialAnimId) +void EventObjectForceSetSpecialAnim(struct EventObject *eventObject, u8 specialAnimId) { - FieldObjectClearAnimIfSpecialAnimActive(mapObject); - FieldObjectSetSpecialAnim(mapObject, specialAnimId); + EventObjectClearAnimIfSpecialAnimActive(eventObject); + EventObjectSetSpecialAnim(eventObject, specialAnimId); } -void FieldObjectClearAnimIfSpecialAnimActive(struct MapObject *mapObject) +void EventObjectClearAnimIfSpecialAnimActive(struct EventObject *eventObject) { - if (mapObject->heldMovementActive) + if (eventObject->heldMovementActive) { - FieldObjectClearAnim(mapObject); + EventObjectClearAnim(eventObject); } } -void FieldObjectClearAnim(struct MapObject *mapObject) +void EventObjectClearAnim(struct EventObject *eventObject) { - mapObject->movementActionId = 0xFF; - mapObject->heldMovementActive = FALSE; - mapObject->heldMovementFinished = FALSE; - gSprites[mapObject->spriteId].data[1] = 0; - gSprites[mapObject->spriteId].data[2] = 0; + eventObject->movementActionId = 0xFF; + eventObject->heldMovementActive = FALSE; + eventObject->heldMovementFinished = FALSE; + gSprites[eventObject->spriteId].data[1] = 0; + gSprites[eventObject->spriteId].data[2] = 0; } -u8 FieldObjectCheckIfSpecialAnimFinishedOrInactive(struct MapObject *mapObject) +u8 EventObjectCheckIfSpecialAnimFinishedOrInactive(struct EventObject *eventObject) { - if (mapObject->heldMovementActive) + if (eventObject->heldMovementActive) { - return mapObject->heldMovementFinished; + return eventObject->heldMovementFinished; } return 0x10; } -u8 FieldObjectClearAnimIfSpecialAnimFinished(struct MapObject *mapObject) +u8 EventObjectClearAnimIfSpecialAnimFinished(struct EventObject *eventObject) { u8 specialAnimState; - specialAnimState = FieldObjectCheckIfSpecialAnimFinishedOrInactive(mapObject); + specialAnimState = EventObjectCheckIfSpecialAnimFinishedOrInactive(eventObject); if (specialAnimState != 0 && specialAnimState != 16) { - FieldObjectClearAnimIfSpecialAnimActive(mapObject); + EventObjectClearAnimIfSpecialAnimActive(eventObject); } return specialAnimState; } -u8 FieldObjectGetSpecialAnim(struct MapObject *mapObject) +u8 EventObjectGetSpecialAnim(struct EventObject *eventObject) { - if (mapObject->heldMovementActive) + if (eventObject->heldMovementActive) { - return mapObject->movementActionId; + return eventObject->movementActionId; } return 0xFF; } -void FieldObjectStep(struct MapObject *mapObject, struct Sprite *sprite, bool8 (*callback)(struct MapObject *, struct Sprite *)) +void EventObjectStep(struct EventObject *eventObject, struct Sprite *sprite, bool8 (*callback)(struct EventObject *, struct Sprite *)) { - DoGroundEffects_OnSpawn(mapObject, sprite); - sub_80964E8(mapObject, sprite); - if (FieldObjectIsSpecialAnimActive(mapObject)) + DoGroundEffects_OnSpawn(eventObject, sprite); + sub_80964E8(eventObject, sprite); + if (EventObjectIsSpecialAnimActive(eventObject)) { - FieldObjectExecSpecialAnim(mapObject, sprite); + EventObjectExecSpecialAnim(eventObject, sprite); } - else if (!mapObject->frozen) + else if (!eventObject->frozen) { - while (callback(mapObject, sprite)); + while (callback(eventObject, sprite)); } - DoGroundEffects_OnBeginStep(mapObject, sprite); - DoGroundEffects_OnFinishStep(mapObject, sprite); - npc_obj_transfer_image_anim_pause_flag(mapObject, sprite); - sub_8096518(mapObject, sprite); - FieldObjectUpdateSubpriority(mapObject, sprite); + DoGroundEffects_OnBeginStep(eventObject, sprite); + DoGroundEffects_OnFinishStep(eventObject, sprite); + npc_obj_transfer_image_anim_pause_flag(eventObject, sprite); + sub_8096518(eventObject, sprite); + EventObjectUpdateSubpriority(eventObject, sprite); } #define dirn2anim_2(name, table) \ @@ -4973,9 +4971,9 @@ dirn2anim_2(GetStepInPlaceDelay16AnimId, gUnknown_0850DBE6); dirn2anim_2(GetStepInPlaceDelay8AnimId, gUnknown_0850DBEB); dirn2anim_2(GetStepInPlaceDelay4AnimId, gUnknown_0850DBF0); -bool8 FieldObjectFaceOppositeDirection(struct MapObject *mapObject, u8 direction) +bool8 EventObjectFaceOppositeDirection(struct EventObject *eventObject, u8 direction) { - return FieldObjectSetSpecialAnim(mapObject, GetFaceDirectionAnimId(GetOppositeDirection(direction))); + return EventObjectSetSpecialAnim(eventObject, GetFaceDirectionAnimId(GetOppositeDirection(direction))); } dirn2anim_2(sub_8093648, gUnknown_0850DBF5); @@ -5022,141 +5020,141 @@ static u32 state_to_direction(u8 a0, u32 a1, u32 a2) return gUnknown_0850DC3F[a0 - 1][zffuOffset - 1]; } -static void FieldObjectExecSpecialAnim(struct MapObject *mapObject, struct Sprite *sprite) +static void EventObjectExecSpecialAnim(struct EventObject *eventObject, struct Sprite *sprite) { - if (gUnknown_0850DC50[mapObject->movementActionId][sprite->data[2]](mapObject, sprite)) + if (gUnknown_0850DC50[eventObject->movementActionId][sprite->data[2]](eventObject, sprite)) { - mapObject->heldMovementFinished = TRUE; + eventObject->heldMovementFinished = TRUE; } } -bool8 FieldObjectExecRegularAnim(struct MapObject *mapObject, struct Sprite *sprite) +bool8 EventObjectExecRegularAnim(struct EventObject *eventObject, struct Sprite *sprite) { - if (gUnknown_0850DC50[mapObject->movementActionId][sprite->data[2]](mapObject, sprite)) + if (gUnknown_0850DC50[eventObject->movementActionId][sprite->data[2]](eventObject, sprite)) { - mapObject->movementActionId = 0xFF; + eventObject->movementActionId = 0xFF; sprite->data[2] = 0; return TRUE; } return FALSE; } -static void FieldObjectSetRegularAnim(struct MapObject *mapObject, struct Sprite *sprite, u8 animId) +static void EventObjectSetRegularAnim(struct EventObject *eventObject, struct Sprite *sprite, u8 animId) { - mapObject->movementActionId = animId; + eventObject->movementActionId = animId; sprite->data[2] = 0; } // file boundary? -void an_look_any(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +void an_look_any(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) { - FieldObjectSetDirection(mapObject, direction); - npc_coords_shift_still(mapObject); - obj_npc_animation_step(mapObject, sprite, get_go_image_anim_num(mapObject->facingDirection)); + EventObjectSetDirection(eventObject, direction); + npc_coords_shift_still(eventObject); + obj_npc_animation_step(eventObject, sprite, get_go_image_anim_num(eventObject->facingDirection)); sprite->animPaused = TRUE; sprite->data[2] = 1; } -bool8 sub_8093950(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8093950(struct EventObject *eventObject, struct Sprite *sprite) { - an_look_any(mapObject, sprite, DIR_SOUTH); + an_look_any(eventObject, sprite, DIR_SOUTH); return TRUE; } -bool8 sub_8093960(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8093960(struct EventObject *eventObject, struct Sprite *sprite) { - an_look_any(mapObject, sprite, DIR_NORTH); + an_look_any(eventObject, sprite, DIR_NORTH); return TRUE; } -bool8 sub_8093970(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8093970(struct EventObject *eventObject, struct Sprite *sprite) { - an_look_any(mapObject, sprite, DIR_WEST); + an_look_any(eventObject, sprite, DIR_WEST); return TRUE; } -bool8 sub_8093980(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8093980(struct EventObject *eventObject, struct Sprite *sprite) { - an_look_any(mapObject, sprite, DIR_EAST); + an_look_any(eventObject, sprite, DIR_EAST); return TRUE; } -void npc_apply_direction(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +void npc_apply_direction(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) { s16 x; s16 y; - x = mapObject->currentCoords.x; - y = mapObject->currentCoords.y; - FieldObjectSetDirection(mapObject, direction); + x = eventObject->currentCoords.x; + y = eventObject->currentCoords.y; + EventObjectSetDirection(eventObject, direction); MoveCoords(direction, &x, &y); - npc_coords_shift(mapObject, x, y); + npc_coords_shift(eventObject, x, y); oamt_npc_ministep_reset(sprite, direction, speed); sprite->animPaused = FALSE; - if (gUnknown_020375B8 != NULL && sub_8097F78(mapObject) != 0x10) + if (gUnknown_020375B8 != NULL && sub_8097F78(eventObject) != 0x10) { sprite->animPaused = TRUE; } - mapObject->triggerGroundEffectsOnMove = TRUE; + eventObject->triggerGroundEffectsOnMove = TRUE; sprite->data[2] = 1; } -void do_go_anim(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +void do_go_anim(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) { u8 (*functions[ARRAY_COUNT(gUnknown_0850DEE8)])(u8); memcpy(functions, gUnknown_0850DEE8, sizeof gUnknown_0850DEE8); - npc_apply_direction(mapObject, sprite, direction, speed); - npc_apply_anim_looping(mapObject, sprite, functions[speed](mapObject->facingDirection)); + npc_apply_direction(eventObject, sprite, direction, speed); + npc_apply_anim_looping(eventObject, sprite, functions[speed](eventObject->facingDirection)); } -void do_run_anim(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +void do_run_anim(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) { - npc_apply_direction(mapObject, sprite, direction, 1); - npc_apply_anim_looping(mapObject, sprite, get_run_image_anim_num(mapObject->facingDirection)); + npc_apply_direction(eventObject, sprite, direction, 1); + npc_apply_anim_looping(eventObject, sprite, get_run_image_anim_num(eventObject->facingDirection)); } -bool8 npc_obj_ministep_stop_on_arrival(struct MapObject *mapObject, struct Sprite *sprite) +bool8 npc_obj_ministep_stop_on_arrival(struct EventObject *eventObject, struct Sprite *sprite) { if (obj_npc_ministep(sprite)) { - npc_coords_shift_still(mapObject); - mapObject->triggerGroundEffectsOnStop = TRUE; + npc_coords_shift_still(eventObject); + eventObject->triggerGroundEffectsOnStop = TRUE; sprite->animPaused = TRUE; return TRUE; } return FALSE; } -void sub_8093AF0(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +void sub_8093AF0(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) { s16 x; s16 y; - x = mapObject->currentCoords.x; - y = mapObject->currentCoords.y; - FieldObjectSetDirection(mapObject, direction); + x = eventObject->currentCoords.x; + y = eventObject->currentCoords.y; + EventObjectSetDirection(eventObject, direction); MoveCoords(direction, &x, &y); - npc_coords_shift(mapObject, x, y); + npc_coords_shift(eventObject, x, y); sub_80976DC(sprite, direction); sprite->animPaused = FALSE; - mapObject->triggerGroundEffectsOnMove = TRUE; + eventObject->triggerGroundEffectsOnMove = TRUE; sprite->data[2] = 1; } -void sub_8093B60(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +void sub_8093B60(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) { - sub_8093AF0(mapObject, sprite, direction); - npc_apply_anim_looping(mapObject, sprite, get_go_image_anim_num(mapObject->facingDirection)); + sub_8093AF0(eventObject, sprite, direction); + npc_apply_anim_looping(eventObject, sprite, get_go_image_anim_num(eventObject->facingDirection)); } -bool8 an_walk_any_2(struct MapObject *mapObject, struct Sprite *sprite) +bool8 an_walk_any_2(struct EventObject *eventObject, struct Sprite *sprite) { if (sub_80976EC(sprite)) { - npc_coords_shift_still(mapObject); - mapObject->triggerGroundEffectsOnStop = TRUE; + npc_coords_shift_still(eventObject); + eventObject->triggerGroundEffectsOnStop = TRUE; sprite->animPaused = TRUE; return TRUE; } @@ -5164,15 +5162,15 @@ bool8 an_walk_any_2(struct MapObject *mapObject, struct Sprite *sprite) } #define an_walk_any_2_macro(name, fn1, fn2, ...) \ -bool8 name##_2(struct MapObject *, struct Sprite *);\ -bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name##_2(struct EventObject *, struct Sprite *);\ +bool8 name(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - fn1(mapObject, sprite, __VA_ARGS__);\ - return name##_2(mapObject, sprite);\ + fn1(eventObject, sprite, __VA_ARGS__);\ + return name##_2(eventObject, sprite);\ }\ -bool8 name##_2(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name##_2(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - if (fn2(mapObject, sprite))\ + if (fn2(eventObject, sprite))\ {\ sprite->data[2] = 2;\ return TRUE;\ @@ -5197,7 +5195,7 @@ an_walk_any_2_macro(sub_8093F04, do_go_anim, npc_obj_ministep_stop_on_arrival, 2 an_walk_any_2_macro(sub_8093F44, do_go_anim, npc_obj_ministep_stop_on_arrival, 3, 0) an_walk_any_2_macro(sub_8093F84, do_go_anim, npc_obj_ministep_stop_on_arrival, 4, 0) -void sub_8093FC4(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a5) +void sub_8093FC4(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a5) { s16 displacements[ARRAY_COUNT(gUnknown_0850DFBC)]; s16 x; @@ -5206,24 +5204,24 @@ void sub_8093FC4(struct MapObject *mapObject, struct Sprite *sprite, u8 directio memcpy(displacements, gUnknown_0850DFBC, sizeof gUnknown_0850DFBC); x = 0; y = 0; - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sub_8092F88(direction, &x, &y, displacements[speed], displacements[speed]); - npc_coords_shift(mapObject, mapObject->currentCoords.x + x, mapObject->currentCoords.y + y); + npc_coords_shift(eventObject, eventObject->currentCoords.x + x, eventObject->currentCoords.y + y); sub_809783C(sprite, direction, speed, a5); sprite->data[2] = 1; sprite->animPaused = 0; - mapObject->triggerGroundEffectsOnMove = 1; - mapObject->disableCoveringGroundEffects = 1; + eventObject->triggerGroundEffectsOnMove = 1; + eventObject->disableCoveringGroundEffects = 1; } -void maybe_shadow_1(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a4) +void maybe_shadow_1(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a4) { - sub_8093FC4(mapObject, sprite, direction, speed, a4); - npc_apply_anim_looping(mapObject, sprite, get_go_image_anim_num(mapObject->facingDirection)); - DoShadowFieldEffect(mapObject); + sub_8093FC4(eventObject, sprite, direction, speed, a4); + npc_apply_anim_looping(eventObject, sprite, get_go_image_anim_num(eventObject->facingDirection)); + DoShadowFieldEffect(eventObject); } -u8 sub_80940C4(struct MapObject *mapObject, struct Sprite *sprite, u8 callback(struct Sprite *)) +u8 sub_80940C4(struct EventObject *eventObject, struct Sprite *sprite, u8 callback(struct Sprite *)) { s16 displacements[ARRAY_COUNT(gUnknown_0850DFC2)]; s16 x; @@ -5236,75 +5234,75 @@ u8 sub_80940C4(struct MapObject *mapObject, struct Sprite *sprite, u8 callback(s { x = 0; y = 0; - sub_8092F88(mapObject->movementDirection, &x, &y, displacements[sprite->data[4]], displacements[sprite->data[4]]); - npc_coords_shift(mapObject, mapObject->currentCoords.x + x, mapObject->currentCoords.y + y); - mapObject->triggerGroundEffectsOnMove = TRUE; - mapObject->disableCoveringGroundEffects = TRUE; + sub_8092F88(eventObject->movementDirection, &x, &y, displacements[sprite->data[4]], displacements[sprite->data[4]]); + npc_coords_shift(eventObject, eventObject->currentCoords.x + x, eventObject->currentCoords.y + y); + eventObject->triggerGroundEffectsOnMove = TRUE; + eventObject->disableCoveringGroundEffects = TRUE; } else if (result == 0xFF) { - npc_coords_shift_still(mapObject); - mapObject->triggerGroundEffectsOnStop = TRUE; - mapObject->landingJump = TRUE; + npc_coords_shift_still(eventObject); + eventObject->triggerGroundEffectsOnStop = TRUE; + eventObject->landingJump = TRUE; sprite->animPaused = TRUE; } return result; } -u8 sub_8094188(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_8094188(struct EventObject *eventObject, struct Sprite *sprite) { - return sub_80940C4(mapObject, sprite, sub_809785C); + return sub_80940C4(eventObject, sprite, sub_809785C); } -u8 sub_809419C(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_809419C(struct EventObject *eventObject, struct Sprite *sprite) { - return sub_80940C4(mapObject, sprite, sub_80978E4); + return sub_80940C4(eventObject, sprite, sub_80978E4); } -bool8 sub_80941B0(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80941B0(struct EventObject *eventObject, struct Sprite *sprite) { - if (sub_8094188(mapObject, sprite) == 0xFF) + if (sub_8094188(eventObject, sprite) == 0xFF) { return TRUE; } return FALSE; } -bool8 sub_80941C8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80941C8(struct EventObject *eventObject, struct Sprite *sprite) { - if (sub_809419C(mapObject, sprite) == 0xFF) + if (sub_809419C(eventObject, sprite) == 0xFF) { return TRUE; } return FALSE; } -bool8 sub_80941E0(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80941E0(struct EventObject *eventObject, struct Sprite *sprite) { - switch (sub_8094188(mapObject, sprite)) + switch (sub_8094188(eventObject, sprite)) { case 255: return TRUE; case 1: - FieldObjectSetDirection(mapObject, GetOppositeDirection(mapObject->movementDirection)); - obj_npc_animation_step(mapObject, sprite, get_go_image_anim_num(mapObject->facingDirection)); + EventObjectSetDirection(eventObject, GetOppositeDirection(eventObject->movementDirection)); + obj_npc_animation_step(eventObject, sprite, get_go_image_anim_num(eventObject->facingDirection)); default: return FALSE; } } #define maybe_shadow_1_macro(name, fn1, fn2, ...) \ -bool8 name##_2(struct MapObject *, struct Sprite *);\ -bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name##_2(struct EventObject *, struct Sprite *);\ +bool8 name(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - fn1(mapObject, sprite, __VA_ARGS__);\ - return name##_2(mapObject, sprite);\ + fn1(eventObject, sprite, __VA_ARGS__);\ + return name##_2(eventObject, sprite);\ }\ -bool8 name##_2(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name##_2(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - if (fn2(mapObject, sprite))\ + if (fn2(eventObject, sprite))\ {\ - mapObject->hasShadow = FALSE;\ + eventObject->hasShadow = FALSE;\ sprite->data[2] = 2;\ return TRUE;\ }\ @@ -5322,7 +5320,7 @@ void sub_8094390(struct Sprite *sprite, u16 duration) sprite->data[3] = duration; } -bool8 sub_8094398(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8094398(struct EventObject *eventObject, struct Sprite *sprite) { if (-- sprite->data[3] == 0) { @@ -5333,10 +5331,10 @@ bool8 sub_8094398(struct MapObject *mapObject, struct Sprite *sprite) } #define special_anim_with_timer(name, duration)\ -bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name(struct EventObject *eventObject, struct Sprite *sprite)\ {\ sub_8094390(sprite, duration);\ - return sub_8094398(mapObject, sprite);\ + return sub_8094398(eventObject, sprite);\ } special_anim_with_timer(sub_80943B4, 1) @@ -5350,16 +5348,16 @@ an_walk_any_2_macro(sub_8094494, do_go_anim, npc_obj_ministep_stop_on_arrival, 2 an_walk_any_2_macro(sub_80944D4, do_go_anim, npc_obj_ministep_stop_on_arrival, 3, 1) an_walk_any_2_macro(sub_8094514, do_go_anim, npc_obj_ministep_stop_on_arrival, 4, 1) -void sub_8094554(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 animNum, u16 duration) +void sub_8094554(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 animNum, u16 duration) { - FieldObjectSetDirection(mapObject, direction); - npc_apply_anim_looping(mapObject, sprite, animNum); + EventObjectSetDirection(eventObject, direction); + npc_apply_anim_looping(eventObject, sprite, animNum); sprite->animPaused = FALSE; sprite->data[2] = 1; sprite->data[3] = duration; } -bool8 sub_809459C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_809459C(struct EventObject *eventObject, struct Sprite *sprite) { if (-- sprite->data[3] == 0) { @@ -5370,22 +5368,22 @@ bool8 sub_809459C(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_80945C4(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80945C4(struct EventObject *eventObject, struct Sprite *sprite) { if (sprite->data[3] & 1) { sprite->animDelayCounter ++; } - return sub_809459C(mapObject, sprite); + return sub_809459C(eventObject, sprite); } #define special_anim_with_timer_2(name, direction, images, duration, timer) \ -bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name(struct EventObject *eventObject, struct Sprite *sprite)\ {\ u8 animId;\ animId = images(DIR_##direction);\ - sub_8094554(mapObject, sprite, DIR_##direction, animId, duration);\ - return timer(mapObject, sprite);\ + sub_8094554(eventObject, sprite, DIR_##direction, animId, duration);\ + return timer(eventObject, sprite);\ } special_anim_with_timer_2(sub_8094600, SOUTH, get_go_image_anim_num, 32, sub_80945C4) @@ -5422,20 +5420,20 @@ an_walk_any_2_macro(sub_8094CC0, do_run_anim, npc_obj_ministep_stop_on_arrival, an_walk_any_2_macro(sub_8094D00, do_run_anim, npc_obj_ministep_stop_on_arrival, DIR_WEST) an_walk_any_2_macro(sub_8094D40, do_run_anim, npc_obj_ministep_stop_on_arrival, DIR_EAST) -void npc_set_direction_and_anim__an_proceed(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 animNum) +void npc_set_direction_and_anim__an_proceed(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 animNum) { obj_anim_image_set_and_seek(sprite, animNum, 0); - FieldObjectSetDirection(mapObject, direction); + EventObjectSetDirection(eventObject, direction); sprite->data[2] = 1; } -bool8 sub_8094DAC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8094DAC(struct EventObject *eventObject, struct Sprite *sprite) { - npc_set_direction_and_anim__an_proceed(mapObject, sprite, mapObject->movementDirection, sprite->animNum); + npc_set_direction_and_anim__an_proceed(eventObject, sprite, eventObject->movementDirection, sprite->animNum); return FALSE; } -bool8 sub_8094DC4(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8094DC4(struct EventObject *eventObject, struct Sprite *sprite) { if (sub_80979BC(sprite)) { @@ -5445,25 +5443,25 @@ bool8 sub_8094DC4(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -void sub_8094DE4(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +void sub_8094DE4(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) { - sub_8093FC4(mapObject, sprite, direction, 1, 0); + sub_8093FC4(eventObject, sprite, direction, 1, 0); StartSpriteAnim(sprite, sub_80929AC(direction)); } #define unk_macro_8094E18(name, direction)\ -bool8 name##_2(struct MapObject *, struct Sprite *);\ -bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name##_2(struct EventObject *, struct Sprite *);\ +bool8 name(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - sub_8094DE4(mapObject, sprite, direction);\ - return name##_2(mapObject, sprite);\ + sub_8094DE4(eventObject, sprite, direction);\ + return name##_2(eventObject, sprite);\ }\ -bool8 name##_2(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name##_2(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - if (sub_80941C8(mapObject, sprite))\ + if (sub_80941C8(eventObject, sprite))\ {\ sprite->data[2] = 2;\ - mapObject->landingJump = FALSE;\ + eventObject->landingJump = FALSE;\ return TRUE;\ }\ return FALSE;\ @@ -5474,40 +5472,40 @@ unk_macro_8094E18(sub_8094E60, DIR_NORTH) unk_macro_8094E18(sub_8094EB8, DIR_WEST) unk_macro_8094E18(sub_8094710, DIR_EAST) -bool8 sub_8094F38(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8094F38(struct EventObject *eventObject, struct Sprite *sprite) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(0xFF, 0, 0, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(0xFF, 0, 0, &eventObjectId)) { - an_look_any(mapObject, sprite, sub_8092AF8(mapObject->currentCoords.x, mapObject->currentCoords.y, gMapObjects[mapObjectId].currentCoords.x, gMapObjects[mapObjectId].currentCoords.y)); + an_look_any(eventObject, sprite, sub_8092AF8(eventObject->currentCoords.x, eventObject->currentCoords.y, gEventObjects[eventObjectId].currentCoords.x, gEventObjects[eventObjectId].currentCoords.y)); } sprite->data[2] = 1; return TRUE; } -bool8 sub_8094F94(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8094F94(struct EventObject *eventObject, struct Sprite *sprite) { - u8 mapObjectId; + u8 eventObjectId; - if (!TryGetFieldObjectIdByLocalIdAndMap(0xFF, 0, 0, &mapObjectId)) + if (!TryGetEventObjectIdByLocalIdAndMap(0xFF, 0, 0, &eventObjectId)) { - an_look_any(mapObject, sprite, GetOppositeDirection(sub_8092AF8(mapObject->currentCoords.x, mapObject->currentCoords.y, gMapObjects[mapObjectId].currentCoords.x, gMapObjects[mapObjectId].currentCoords.y))); + an_look_any(eventObject, sprite, GetOppositeDirection(sub_8092AF8(eventObject->currentCoords.x, eventObject->currentCoords.y, gEventObjects[eventObjectId].currentCoords.x, gEventObjects[eventObjectId].currentCoords.y))); } sprite->data[2] = 1; return TRUE; } -bool8 sub_8094FF8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8094FF8(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->facingDirectionLocked = TRUE; + eventObject->facingDirectionLocked = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 sub_8095008(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095008(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->facingDirectionLocked = FALSE; + eventObject->facingDirectionLocked = FALSE; sprite->data[2] = 1; return TRUE; } @@ -5525,104 +5523,104 @@ maybe_shadow_1_macro(sub_8095330, maybe_shadow_1, sub_80941E0, DIR_NORTH, 0, 2) maybe_shadow_1_macro(sub_8095388, maybe_shadow_1, sub_80941E0, DIR_WEST, 0, 2) maybe_shadow_1_macro(sub_80953E0, maybe_shadow_1, sub_80941E0, DIR_EAST, 0, 2) -bool8 sub_8095438(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095438(struct EventObject *eventObject, struct Sprite *sprite) { - an_look_any(mapObject, sprite, gInitialMovementTypeFacingDirections[mapObject->movementType]); + an_look_any(eventObject, sprite, gInitialMovementTypeFacingDirections[eventObject->movementType]); return TRUE; } -bool8 sub_8095450(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095450(struct EventObject *eventObject, struct Sprite *sprite) { - npc_set_direction_and_anim__an_proceed(mapObject, sprite, DIR_SOUTH, 0x14); + npc_set_direction_and_anim__an_proceed(eventObject, sprite, DIR_SOUTH, 0x14); return FALSE; } -bool8 sub_8095460(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095460(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->disableJumpLandingGroundEffect = FALSE; + eventObject->disableJumpLandingGroundEffect = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 sub_8095470(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095470(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->disableJumpLandingGroundEffect = TRUE; + eventObject->disableJumpLandingGroundEffect = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 sub_8095480(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095480(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->inanimate = TRUE; + eventObject->inanimate = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 sub_8095490(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095490(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->inanimate = GetFieldObjectGraphicsInfo(mapObject->graphicsId)->inanimate; + eventObject->inanimate = GetEventObjectGraphicsInfo(eventObject->graphicsId)->inanimate; sprite->data[2] = 1; return TRUE; } -bool8 sub_80954BC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80954BC(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->invisible = TRUE; + eventObject->invisible = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 sub_80954CC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80954CC(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->invisible = FALSE; + eventObject->invisible = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 do_exclamation_mark_bubble_1(struct MapObject *mapObject, struct Sprite *sprite) +bool8 do_exclamation_mark_bubble_1(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectGetLocalIdAndMap(mapObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON_1); sprite->data[2] = 1; return TRUE; } -bool8 do_exclamation_mark_bubble_2(struct MapObject *mapObject, struct Sprite *sprite) +bool8 do_exclamation_mark_bubble_2(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectGetLocalIdAndMap(mapObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON_2); sprite->data[2] = 1; return TRUE; } -bool8 do_heart_bubble(struct MapObject *mapObject, struct Sprite *sprite) +bool8 do_heart_bubble(struct EventObject *eventObject, struct Sprite *sprite) { - FieldObjectGetLocalIdAndMap(mapObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_HEART_ICON); sprite->data[2] = 1; return TRUE; } -bool8 sub_8095548(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095548(struct EventObject *eventObject, struct Sprite *sprite) { - if (mapObject->movementType == 0x3F) + if (eventObject->movementType == 0x3F) { - sub_80B4578(mapObject); + sub_80B4578(eventObject); return FALSE; } - if (mapObject->movementType != 0x39 && mapObject->movementType != 0x3A) + if (eventObject->movementType != 0x39 && eventObject->movementType != 0x3A) { sprite->data[2] = 2; return TRUE; } - sub_8155D78(mapObject); + sub_8155D78(eventObject); sprite->data[2] = 1; - return sub_809558C(mapObject, sprite); + return sub_809558C(eventObject, sprite); } -bool8 sub_809558C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_809558C(struct EventObject *eventObject, struct Sprite *sprite) { - if (sub_8155DA0(mapObject)) + if (sub_8155DA0(eventObject)) { sprite->data[2] = 2; return TRUE; @@ -5630,77 +5628,77 @@ bool8 sub_809558C(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -bool8 sub_80955AC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80955AC(struct EventObject *eventObject, struct Sprite *sprite) { obj_anim_image_set_and_seek(sprite, 1, 0); sprite->data[2] = 1; return FALSE; } -bool8 sub_80955C8(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80955C8(struct EventObject *eventObject, struct Sprite *sprite) { if (sub_80979BC(sprite)) { - SetFieldObjectStepTimer(sprite, 32); + SetEventObjectStepTimer(sprite, 32); sprite->data[2] = 2; } return FALSE; } -bool8 sub_80955EC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80955EC(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->invisible ^= TRUE; - if (RunFieldObjectStepTimer(sprite)) + eventObject->invisible ^= TRUE; + if (RunEventObjectStepTimer(sprite)) { - mapObject->invisible = TRUE; + eventObject->invisible = TRUE; sprite->data[2] = 3; } return FALSE; } -bool8 sub_8095628(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095628(struct EventObject *eventObject, struct Sprite *sprite) { obj_anim_image_set_and_seek(sprite, 1, 0); sprite->data[2] = 1; return FALSE; } -bool8 sub_8095644(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095644(struct EventObject *eventObject, struct Sprite *sprite) { if (sub_80979BC(sprite)) { - SetFieldObjectStepTimer(sprite, 32); + SetEventObjectStepTimer(sprite, 32); sprite->data[2] = 2; } return FALSE; } -bool8 sub_8095668(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095668(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->invisible ^= TRUE; - if (RunFieldObjectStepTimer(sprite)) + eventObject->invisible ^= TRUE; + if (RunEventObjectStepTimer(sprite)) { - mapObject->invisible = TRUE; + eventObject->invisible = TRUE; sprite->data[2] = 3; } return FALSE; } -bool8 sub_80956A4(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80956A4(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->fixedPriority = TRUE; + eventObject->fixedPriority = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 sub_80956B4(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80956B4(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->fixedPriority = FALSE; + eventObject->fixedPriority = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 sub_80956C4(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80956C4(struct EventObject *eventObject, struct Sprite *sprite) { sprite->oam.affineMode = 3; InitSpriteAffineAnim(sprite); @@ -5709,7 +5707,7 @@ bool8 sub_80956C4(struct MapObject *mapObject, struct Sprite *sprite) return TRUE; } -bool8 sub_80956F4(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80956F4(struct EventObject *eventObject, struct Sprite *sprite) { FreeOamMatrix(sprite->oam.matrixNum); sprite->oam.affineMode = 0; @@ -5717,30 +5715,30 @@ bool8 sub_80956F4(struct MapObject *mapObject, struct Sprite *sprite) return TRUE; } -bool8 sub_8095724(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095724(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->unk3_3 = TRUE; + eventObject->unk3_3 = TRUE; return TRUE; } -bool8 sub_8095730(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095730(struct EventObject *eventObject, struct Sprite *sprite) { - mapObject->unk3_3 = FALSE; + eventObject->unk3_3 = FALSE; return TRUE; } #define affine_an_walk_any_2_macro(name, fn, fn2, action, anim, ...)\ -bool8 name##_2(struct MapObject *, struct Sprite *);\ -bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name##_2(struct EventObject *, struct Sprite *);\ +bool8 name(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - fn(mapObject, sprite, __VA_ARGS__);\ + fn(eventObject, sprite, __VA_ARGS__);\ sprite->affineAnimPaused = FALSE;\ action(sprite, anim);\ - return name##_2(mapObject, sprite);\ + return name##_2(eventObject, sprite);\ }\ -bool8 name##_2(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name##_2(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - if (fn2(mapObject, sprite))\ + if (fn2(eventObject, sprite))\ {\ sprite->affineAnimPaused = TRUE;\ sprite->data[2] = 2;\ @@ -5754,43 +5752,43 @@ affine_an_walk_any_2_macro(sub_80957A0, sub_8093B60, an_walk_any_2, ChangeSprite affine_an_walk_any_2_macro(sub_8095800, do_go_anim, npc_obj_ministep_stop_on_arrival, ChangeSpriteAffineAnimIfDifferent, 2, DIR_WEST, 1) affine_an_walk_any_2_macro(sub_8095860, do_go_anim, npc_obj_ministep_stop_on_arrival, ChangeSpriteAffineAnimIfDifferent, 3, DIR_EAST, 1) -static void sub_80958C0(struct MapObject *mapObject, struct Sprite *sprite, u8 direction) +static void sub_80958C0(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) { - FieldObjectSetDirection(mapObject, direction); - npc_coords_shift_still(mapObject); - obj_npc_animation_step(mapObject, sprite, sub_80929FC(direction)); + EventObjectSetDirection(eventObject, direction); + npc_coords_shift_still(eventObject); + obj_npc_animation_step(eventObject, sprite, sub_80929FC(direction)); sprite->animPaused = TRUE; sprite->data[2] = 1; } -bool8 sub_8095900(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095900(struct EventObject *eventObject, struct Sprite *sprite) { - sub_80958C0(mapObject, sprite, DIR_SOUTH); + sub_80958C0(eventObject, sprite, DIR_SOUTH); return TRUE; } -bool8 sub_8095910(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095910(struct EventObject *eventObject, struct Sprite *sprite) { - sub_80958C0(mapObject, sprite, DIR_NORTH); + sub_80958C0(eventObject, sprite, DIR_NORTH); return TRUE; } -bool8 sub_8095920(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095920(struct EventObject *eventObject, struct Sprite *sprite) { - sub_80958C0(mapObject, sprite, DIR_WEST); + sub_80958C0(eventObject, sprite, DIR_WEST); return TRUE; } -bool8 sub_8095930(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095930(struct EventObject *eventObject, struct Sprite *sprite) { - sub_80958C0(mapObject, sprite, DIR_EAST); + sub_80958C0(eventObject, sprite, DIR_EAST); return TRUE; } #define set_dirn_and_anim__an_proceed(name, direction, anims)\ -bool8 name(struct MapObject *mapObject, struct Sprite *sprite)\ +bool8 name(struct EventObject *eventObject, struct Sprite *sprite)\ {\ - npc_set_direction_and_anim__an_proceed(mapObject, sprite, direction, anims(direction));\ + npc_set_direction_and_anim__an_proceed(eventObject, sprite, direction, anims(direction));\ return FALSE;\ } @@ -5807,34 +5805,34 @@ set_dirn_and_anim__an_proceed(sub_8095A84, DIR_NORTH, sub_80929EC) set_dirn_and_anim__an_proceed(sub_8095AA8, DIR_WEST, sub_80929EC) set_dirn_and_anim__an_proceed(sub_8095ACC, DIR_EAST, sub_80929EC) -void sub_8095AF0(struct MapObject *mapObject, struct Sprite *sprite) +void sub_8095AF0(struct EventObject *eventObject, struct Sprite *sprite) { sub_8097750(sprite); sprite->animPaused = FALSE; } -bool8 sub_8095B0C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095B0C(struct EventObject *eventObject, struct Sprite *sprite) { if (sub_8097758(sprite)) { - npc_coords_shift_still(mapObject); - mapObject->triggerGroundEffectsOnStop = TRUE; + npc_coords_shift_still(eventObject); + eventObject->triggerGroundEffectsOnStop = TRUE; sprite->animPaused = TRUE; return TRUE; } return FALSE; } -bool8 sub_8095B44(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095B44(struct EventObject *eventObject, struct Sprite *sprite) { - sub_8095AF0(mapObject, sprite); + sub_8095AF0(eventObject, sprite); sprite->data[2] = 1; - return sub_8095B64(mapObject, sprite); + return sub_8095B64(eventObject, sprite); } -bool8 sub_8095B64(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8095B64(struct EventObject *eventObject, struct Sprite *sprite) { - if (sub_8095B0C(mapObject, sprite)) + if (sub_8095B0C(eventObject, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5842,11 +5840,11 @@ bool8 sub_8095B64(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -void sub_8095B84(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a4) +void sub_8095B84(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed, u8 a4) { - sub_8093FC4(mapObject, sprite, direction, speed, a4); + sub_8093FC4(eventObject, sprite, direction, speed, a4); StartSpriteAnimIfDifferent(sprite, sub_80929BC(direction)); - DoShadowFieldEffect(mapObject); + DoShadowFieldEffect(eventObject); } maybe_shadow_1_macro(sub_8095BC8, sub_8095B84, sub_80941B0, DIR_SOUTH, 0, 1) @@ -5867,10 +5865,10 @@ special_anim_with_timer_2(sub_8096020, NORTH, sub_80929FC, 8, sub_809459C) special_anim_with_timer_2(sub_8096058, WEST, sub_80929FC, 8, sub_809459C) special_anim_with_timer_2(sub_8096090, EAST, sub_80929FC, 8, sub_809459C) -void sub_80960C8(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +void sub_80960C8(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) { - npc_apply_direction(mapObject, sprite, direction, speed); - StartSpriteAnim(sprite, sub_80929BC(mapObject->facingDirection)); + npc_apply_direction(eventObject, sprite, direction, speed); + StartSpriteAnim(sprite, sub_80929BC(eventObject->facingDirection)); SeekSpriteAnim(sprite, 0); } @@ -5879,10 +5877,10 @@ an_walk_any_2_macro(sub_8096140, sub_80960C8, npc_obj_ministep_stop_on_arrival, an_walk_any_2_macro(sub_8096180, sub_80960C8, npc_obj_ministep_stop_on_arrival, DIR_WEST, 1) an_walk_any_2_macro(sub_80961C0, sub_80960C8, npc_obj_ministep_stop_on_arrival, DIR_EAST, 1) -void sub_8096200(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +void sub_8096200(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) { - npc_apply_direction(mapObject, sprite, direction, speed); - npc_apply_anim_looping(mapObject, sprite, sub_80929FC(mapObject->facingDirection)); + npc_apply_direction(eventObject, sprite, direction, speed); + npc_apply_anim_looping(eventObject, sprite, sub_80929FC(eventObject->facingDirection)); } an_walk_any_2_macro(sub_8096230, sub_8096200, npc_obj_ministep_stop_on_arrival, DIR_SOUTH, 1) @@ -5890,10 +5888,10 @@ an_walk_any_2_macro(sub_8096270, sub_8096200, npc_obj_ministep_stop_on_arrival, an_walk_any_2_macro(sub_80962B0, sub_8096200, npc_obj_ministep_stop_on_arrival, DIR_WEST, 1) an_walk_any_2_macro(sub_80962F0, sub_8096200, npc_obj_ministep_stop_on_arrival, DIR_EAST, 1) -void sub_8096330(struct MapObject *mapObject, struct Sprite *sprite, u8 direction, u8 speed) +void sub_8096330(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) { - npc_apply_direction(mapObject, sprite, direction, speed); - StartSpriteAnim(sprite, sub_80929DC(mapObject->facingDirection)); + npc_apply_direction(eventObject, sprite, direction, speed); + StartSpriteAnim(sprite, sub_80929DC(eventObject->facingDirection)); SeekSpriteAnim(sprite, 0); } an_walk_any_2_macro(sub_8096368, sub_8096330, npc_obj_ministep_stop_on_arrival, DIR_SOUTH, 1) @@ -5901,77 +5899,77 @@ an_walk_any_2_macro(sub_80963A8, sub_8096330, npc_obj_ministep_stop_on_arrival, an_walk_any_2_macro(sub_80963E8, sub_8096330, npc_obj_ministep_stop_on_arrival, DIR_WEST, 1) an_walk_any_2_macro(sub_8096428, sub_8096330, npc_obj_ministep_stop_on_arrival, DIR_EAST, 1) -bool8 sub_8096468(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8096468(struct EventObject *eventObject, struct Sprite *sprite) { - sub_8097FA4(mapObject); + sub_8097FA4(eventObject); sprite->data[2] = 1; return TRUE; } -bool8 sub_809647C(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_809647C(struct EventObject *eventObject, struct Sprite *sprite) { - sub_8098044(mapObject->warpArrowSpriteId); + sub_8098044(eventObject->warpArrowSpriteId); sprite->pos2.y = 0; sprite->data[2] = 1; return TRUE; } -bool8 sub_8096494(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_8096494(struct EventObject *eventObject, struct Sprite *sprite) { if (sprite->pos2.y == 0) { - sub_8098044(mapObject->warpArrowSpriteId); + sub_8098044(eventObject->warpArrowSpriteId); sprite->data[2] = 1; return TRUE; } return FALSE; } -u8 sub_80964B8(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_80964B8(struct EventObject *eventObject, struct Sprite *sprite) { return TRUE; } -bool8 sub_80964BC(struct MapObject *mapObject, struct Sprite *sprite) +bool8 sub_80964BC(struct EventObject *eventObject, struct Sprite *sprite) { sprite->animPaused = TRUE; return TRUE; } -void npc_obj_transfer_image_anim_pause_flag(struct MapObject *mapObject, struct Sprite *sprite) +void npc_obj_transfer_image_anim_pause_flag(struct EventObject *eventObject, struct Sprite *sprite) { - if (mapObject->disableAnim) + if (eventObject->disableAnim) { sprite->animPaused = TRUE; } } -void sub_80964E8(struct MapObject *mapObject, struct Sprite *sprite) +void sub_80964E8(struct EventObject *eventObject, struct Sprite *sprite) { - if (mapObject->enableAnim) + if (eventObject->enableAnim) { sprite->animPaused = FALSE; - mapObject->disableAnim = FALSE; - mapObject->enableAnim = FALSE; + eventObject->disableAnim = FALSE; + eventObject->enableAnim = FALSE; } } -static void sub_8096518(struct MapObject *mapObject, struct Sprite *sprite) +static void sub_8096518(struct EventObject *eventObject, struct Sprite *sprite) { - sub_8096530(mapObject, sprite); - npc_update_obj_anim_flag(mapObject, sprite); + sub_8096530(eventObject, sprite); + npc_update_obj_anim_flag(eventObject, sprite); } -static void sub_8096530(struct MapObject *mapObject, struct Sprite *sprite) +static void sub_8096530(struct EventObject *eventObject, struct Sprite *sprite) { u16 x; u16 y; u16 x2; u16 y2; - const struct MapObjectGraphicsInfo *graphicsInfo; + const struct EventObjectGraphicsInfo *graphicsInfo; - mapObject->offScreen = FALSE; - graphicsInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); + eventObject->offScreen = FALSE; + graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); if (sprite->coordOffsetEnabled) { x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX + gSpriteCoordOffsetX; @@ -5988,26 +5986,26 @@ static void sub_8096530(struct MapObject *mapObject, struct Sprite *sprite) y2 += graphicsInfo->height; if ((s16)x >= 0x100 || (s16)x2 < -0x10) { - mapObject->offScreen = TRUE; + eventObject->offScreen = TRUE; } if ((s16)y >= 0xB0 || (s16)y2 < -0x10) { - mapObject->offScreen = TRUE; + eventObject->offScreen = TRUE; } } -static void npc_update_obj_anim_flag(struct MapObject *mapObject, struct Sprite *sprite) +static void npc_update_obj_anim_flag(struct EventObject *eventObject, struct Sprite *sprite) { sprite->invisible = FALSE; - if (mapObject->invisible || mapObject->offScreen) + if (eventObject->invisible || eventObject->offScreen) { sprite->invisible = TRUE; } } -/*static*/ void GetAllGroundEffectFlags_OnSpawn(struct MapObject *eventObj, u32 *flags) +/*static*/ void GetAllGroundEffectFlags_OnSpawn(struct EventObject *eventObj, u32 *flags) { - FieldObjectUpdateMetatileBehaviors(eventObj); + EventObjectUpdateMetatileBehaviors(eventObj); GetGroundEffectFlags_Reflection(eventObj, flags); GetGroundEffectFlags_TallGrassOnSpawn(eventObj, flags); GetGroundEffectFlags_LongGrassOnSpawn(eventObj, flags); @@ -6017,9 +6015,9 @@ static void npc_update_obj_anim_flag(struct MapObject *mapObject, struct Sprite GetGroundEffectFlags_HotSprings(eventObj, flags); } -static void GetAllGroundEffectFlags_OnBeginStep(struct MapObject *eventObj, u32 *flags) +static void GetAllGroundEffectFlags_OnBeginStep(struct EventObject *eventObj, u32 *flags) { - FieldObjectUpdateMetatileBehaviors(eventObj); + EventObjectUpdateMetatileBehaviors(eventObj); GetGroundEffectFlags_Reflection(eventObj, flags); GetGroundEffectFlags_TallGrassOnBeginStep(eventObj, flags); GetGroundEffectFlags_LongGrassOnBeginStep(eventObj, flags); @@ -6031,9 +6029,9 @@ static void GetAllGroundEffectFlags_OnBeginStep(struct MapObject *eventObj, u32 GetGroundEffectFlags_HotSprings(eventObj, flags); } -/*static*/ void GetAllGroundEffectFlags_OnFinishStep(struct MapObject *eventObj, u32 *flags) +/*static*/ void GetAllGroundEffectFlags_OnFinishStep(struct EventObject *eventObj, u32 *flags) { - FieldObjectUpdateMetatileBehaviors(eventObj); + EventObjectUpdateMetatileBehaviors(eventObj); GetGroundEffectFlags_ShallowFlowingWater(eventObj, flags); GetGroundEffectFlags_SandHeap(eventObj, flags); GetGroundEffectFlags_Puddle(eventObj, flags); @@ -6044,16 +6042,16 @@ static void GetAllGroundEffectFlags_OnBeginStep(struct MapObject *eventObj, u32 GetGroundEffectFlags_JumpLanding(eventObj, flags); } -static void FieldObjectUpdateMetatileBehaviors(struct MapObject *eventObj) +static void EventObjectUpdateMetatileBehaviors(struct EventObject *eventObj) { eventObj->previousMetatileBehavior = MapGridGetMetatileBehaviorAt(eventObj->previousCoords.x, eventObj->previousCoords.y); eventObj->currentMetatileBehavior = MapGridGetMetatileBehaviorAt(eventObj->currentCoords.x, eventObj->currentCoords.y); } -static void GetGroundEffectFlags_Reflection(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Reflection(struct EventObject *eventObj, u32 *flags) { u32 reflectionFlags[2] = { GROUND_EFFECT_FLAG_REFLECTION, GROUND_EFFECT_FLAG_ICE_REFLECTION }; - u8 type = FieldObjectCheckForReflectiveSurface(eventObj); + u8 type = EventObjectCheckForReflectiveSurface(eventObj); if (type) { @@ -6070,31 +6068,31 @@ static void GetGroundEffectFlags_Reflection(struct MapObject *eventObj, u32 *fla } } -static void GetGroundEffectFlags_TallGrassOnSpawn(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_TallGrassOnSpawn(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsTallGrass(eventObj->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_TALL_GRASS_ON_SPAWN; } -static void GetGroundEffectFlags_TallGrassOnBeginStep(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_TallGrassOnBeginStep(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsTallGrass(eventObj->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_TALL_GRASS_ON_MOVE; } -static void GetGroundEffectFlags_LongGrassOnSpawn(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_LongGrassOnSpawn(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsLongGrass(eventObj->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_LONG_GRASS_ON_SPAWN; } -static void GetGroundEffectFlags_LongGrassOnBeginStep(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_LongGrassOnBeginStep(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsLongGrass(eventObj->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_LONG_GRASS_ON_MOVE; } -static void GetGroundEffectFlags_Tracks(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Tracks(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsDeepSand(eventObj->previousMetatileBehavior)) { @@ -6107,7 +6105,7 @@ static void GetGroundEffectFlags_Tracks(struct MapObject *eventObj, u32 *flags) } } -static void GetGroundEffectFlags_SandHeap(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_SandHeap(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsDeepSand(eventObj->currentMetatileBehavior) && MetatileBehavior_IsDeepSand(eventObj->previousMetatileBehavior)) @@ -6125,7 +6123,7 @@ static void GetGroundEffectFlags_SandHeap(struct MapObject *eventObj, u32 *flags } } -static void GetGroundEffectFlags_ShallowFlowingWater(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_ShallowFlowingWater(struct EventObject *eventObj, u32 *flags) { if ((MetatileBehavior_IsShallowFlowingWater(eventObj->currentMetatileBehavior) && MetatileBehavior_IsShallowFlowingWater(eventObj->previousMetatileBehavior)) @@ -6145,7 +6143,7 @@ static void GetGroundEffectFlags_ShallowFlowingWater(struct MapObject *eventObj, } } -static void GetGroundEffectFlags_Puddle(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Puddle(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsPuddle(eventObj->currentMetatileBehavior) && MetatileBehavior_IsPuddle(eventObj->previousMetatileBehavior)) @@ -6154,13 +6152,13 @@ static void GetGroundEffectFlags_Puddle(struct MapObject *eventObj, u32 *flags) } } -static void GetGroundEffectFlags_Ripple(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Ripple(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_HasRipples(eventObj->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_RIPPLES; } -static void GetGroundEffectFlags_ShortGrass(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_ShortGrass(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsShortGrass(eventObj->currentMetatileBehavior) && MetatileBehavior_IsShortGrass(eventObj->previousMetatileBehavior)) @@ -6178,7 +6176,7 @@ static void GetGroundEffectFlags_ShortGrass(struct MapObject *eventObj, u32 *fla } } -static void GetGroundEffectFlags_HotSprings(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_HotSprings(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsHotSprings(eventObj->currentMetatileBehavior) && MetatileBehavior_IsHotSprings(eventObj->previousMetatileBehavior)) @@ -6196,13 +6194,13 @@ static void GetGroundEffectFlags_HotSprings(struct MapObject *eventObj, u32 *fla } } -static void GetGroundEffectFlags_Seaweed(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Seaweed(struct EventObject *eventObj, u32 *flags) { if (MetatileBehavior_IsSeaweed(eventObj->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_SEAWEED; } -static void GetGroundEffectFlags_JumpLanding(struct MapObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_JumpLanding(struct EventObject *eventObj, u32 *flags) { typedef bool8 (*MetatileFunc)(u8); @@ -6239,9 +6237,9 @@ static void GetGroundEffectFlags_JumpLanding(struct MapObject *eventObj, u32 *fl } } -static u8 FieldObjectCheckForReflectiveSurface(struct MapObject *eventObj) +static u8 EventObjectCheckForReflectiveSurface(struct EventObject *eventObj) { - const struct MapObjectGraphicsInfo *info = GetFieldObjectGraphicsInfo(eventObj->graphicsId); + const struct EventObjectGraphicsInfo *info = GetEventObjectGraphicsInfo(eventObj->graphicsId); // ceil div by tile width? s16 width = (info->width + 8) >> 4; @@ -6311,7 +6309,7 @@ u8 GetLedgeJumpDirection(s16 x, s16 y, u8 z) return 0; } -void FieldObjectSetSpriteOamTableForLongGrass(struct MapObject *eventObj, struct Sprite *sprite) +void EventObjectSetSpriteOamTableForLongGrass(struct EventObject *eventObj, struct Sprite *sprite) { if (eventObj->disableCoveringGroundEffects) return; @@ -6364,12 +6362,12 @@ static const u8 sEventObjectPriorities_08376070[] = { 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 1, }; -void FieldObjectUpdateZCoordAndPriority(struct MapObject *eventObj, struct Sprite *sprite) +void EventObjectUpdateZCoordAndPriority(struct EventObject *eventObj, struct Sprite *sprite) { if (eventObj->fixedPriority) return; - FieldObjectUpdateZCoord(eventObj); + EventObjectUpdateZCoord(eventObj); sprite->subspriteTableNum = sEventObjectPriorities_08376070[eventObj->previousElevation]; sprite->oam.priority = sEventObjectPriorities_08376060[eventObj->previousElevation]; @@ -6386,7 +6384,7 @@ u8 ZCoordToPriority(u8 z) return sEventObjectPriorities_08376060[z]; } -void FieldObjectUpdateZCoord(struct MapObject *eventObj) +void EventObjectUpdateZCoord(struct EventObject *eventObj) { u8 z = MapGridGetZCoordAt(eventObj->currentCoords.x, eventObj->currentCoords.y); u8 z2 = MapGridGetZCoordAt(eventObj->previousCoords.x, eventObj->previousCoords.y); @@ -6410,7 +6408,7 @@ void SetObjectSubpriorityByZCoord(u8 a, struct Sprite *sprite, u8 b) sprite->subpriority = tmp3 + sUnknown_08376050[a] + b; } -static void FieldObjectUpdateSubpriority(struct MapObject *eventObj, struct Sprite *sprite) +static void EventObjectUpdateSubpriority(struct EventObject *eventObj, struct Sprite *sprite) { if (eventObj->fixedPriority) return; @@ -6429,7 +6427,7 @@ bool8 AreZCoordsCompatible(u8 a, u8 b) return TRUE; } -void GroundEffect_SpawnOnTallGrass(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_SpawnOnTallGrass(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; @@ -6442,7 +6440,7 @@ void GroundEffect_SpawnOnTallGrass(struct MapObject *eventObj, struct Sprite *sp FieldEffectStart(FLDEFF_TALL_GRASS); } -void GroundEffect_StepOnTallGrass(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_StepOnTallGrass(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; @@ -6455,7 +6453,7 @@ void GroundEffect_StepOnTallGrass(struct MapObject *eventObj, struct Sprite *spr FieldEffectStart(FLDEFF_TALL_GRASS); } -void GroundEffect_SpawnOnLongGrass(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_SpawnOnLongGrass(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; @@ -6468,7 +6466,7 @@ void GroundEffect_SpawnOnLongGrass(struct MapObject *eventObj, struct Sprite *sp FieldEffectStart(FLDEFF_LONG_GRASS); } -void GroundEffect_StepOnLongGrass(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_StepOnLongGrass(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; @@ -6481,44 +6479,44 @@ void GroundEffect_StepOnLongGrass(struct MapObject *eventObj, struct Sprite *spr FieldEffectStart(FLDEFF_LONG_GRASS); } -void GroundEffect_WaterReflection(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_WaterReflection(struct EventObject *eventObj, struct Sprite *sprite) { SetUpReflection(eventObj, sprite, 0); } -void GroundEffect_IceReflection(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_IceReflection(struct EventObject *eventObj, struct Sprite *sprite) { SetUpReflection(eventObj, sprite, 1); } -void GroundEffect_FlowingWater(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_FlowingWater(struct EventObject *eventObj, struct Sprite *sprite) { StartFieldEffectForEventObject(FLDEFF_FEET_IN_FLOWING_WATER, eventObj); } -static void (*const sGroundEffectTracksFuncs[])(struct MapObject *eventObj, struct Sprite *sprite, u8 a) = { +static void (*const sGroundEffectTracksFuncs[])(struct EventObject *eventObj, struct Sprite *sprite, u8 a) = { DoTracksGroundEffect_None, DoTracksGroundEffect_Footprints, DoTracksGroundEffect_BikeTireTracks, }; -void GroundEffect_SandTracks(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_SandTracks(struct EventObject *eventObj, struct Sprite *sprite) { - const struct MapObjectGraphicsInfo *info = GetFieldObjectGraphicsInfo(eventObj->graphicsId); + const struct EventObjectGraphicsInfo *info = GetEventObjectGraphicsInfo(eventObj->graphicsId); sGroundEffectTracksFuncs[info->tracks](eventObj, sprite, 0); } -void GroundEffect_DeepSandTracks(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_DeepSandTracks(struct EventObject *eventObj, struct Sprite *sprite) { - const struct MapObjectGraphicsInfo *info = GetFieldObjectGraphicsInfo(eventObj->graphicsId); + const struct EventObjectGraphicsInfo *info = GetEventObjectGraphicsInfo(eventObj->graphicsId); sGroundEffectTracksFuncs[info->tracks](eventObj, sprite, 1); } -static void DoTracksGroundEffect_None(struct MapObject *eventObj, struct Sprite *sprite, u8 a) +static void DoTracksGroundEffect_None(struct EventObject *eventObj, struct Sprite *sprite, u8 a) { } -static void DoTracksGroundEffect_Footprints(struct MapObject *eventObj, struct Sprite *sprite, u8 a) +static void DoTracksGroundEffect_Footprints(struct EventObject *eventObj, struct Sprite *sprite, u8 a) { // First half-word is a Field Effect script id. (gFieldEffectScriptPointers) u16 sandFootprints_FieldEffectData[2] = { @@ -6534,7 +6532,7 @@ static void DoTracksGroundEffect_Footprints(struct MapObject *eventObj, struct S FieldEffectStart(sandFootprints_FieldEffectData[a]); } -static void DoTracksGroundEffect_BikeTireTracks(struct MapObject *eventObj, struct Sprite *sprite, u8 a) +static void DoTracksGroundEffect_BikeTireTracks(struct EventObject *eventObj, struct Sprite *sprite, u8 a) { // Specifies which bike track shape to show next. // For example, when the bike turns from up to right, it will show @@ -6561,22 +6559,22 @@ static void DoTracksGroundEffect_BikeTireTracks(struct MapObject *eventObj, stru } } -void GroundEffect_Ripple(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_Ripple(struct EventObject *eventObj, struct Sprite *sprite) { DoRippleFieldEffect(eventObj, sprite); } -void GroundEffect_StepOnPuddle(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_StepOnPuddle(struct EventObject *eventObj, struct Sprite *sprite) { StartFieldEffectForEventObject(FLDEFF_SPLASH, eventObj); } -void GroundEffect_SandHeap(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_SandHeap(struct EventObject *eventObj, struct Sprite *sprite) { StartFieldEffectForEventObject(FLDEFF_SAND_PILE, eventObj); } -void GroundEffect_JumpOnTallGrass(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpOnTallGrass(struct EventObject *eventObj, struct Sprite *sprite) { u8 spriteId; @@ -6593,7 +6591,7 @@ void GroundEffect_JumpOnTallGrass(struct MapObject *eventObj, struct Sprite *spr GroundEffect_SpawnOnTallGrass(eventObj, sprite); } -void GroundEffect_JumpOnLongGrass(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpOnLongGrass(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; @@ -6602,7 +6600,7 @@ void GroundEffect_JumpOnLongGrass(struct MapObject *eventObj, struct Sprite *spr FieldEffectStart(FLDEFF_JUMP_LONG_GRASS); } -void GroundEffect_JumpOnShallowWater(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpOnShallowWater(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; @@ -6611,7 +6609,7 @@ void GroundEffect_JumpOnShallowWater(struct MapObject *eventObj, struct Sprite * FieldEffectStart(FLDEFF_JUMP_SMALL_SPLASH); } -void GroundEffect_JumpOnWater(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpOnWater(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; @@ -6620,7 +6618,7 @@ void GroundEffect_JumpOnWater(struct MapObject *eventObj, struct Sprite *sprite) FieldEffectStart(FLDEFF_JUMP_BIG_SPLASH); } -void GroundEffect_JumpLandingDust(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpLandingDust(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; @@ -6629,24 +6627,24 @@ void GroundEffect_JumpLandingDust(struct MapObject *eventObj, struct Sprite *spr FieldEffectStart(FLDEFF_DUST); } -void GroundEffect_ShortGrass(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_ShortGrass(struct EventObject *eventObj, struct Sprite *sprite) { StartFieldEffectForEventObject(FLDEFF_SHORT_GRASS, eventObj); } -void GroundEffect_HotSprings(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_HotSprings(struct EventObject *eventObj, struct Sprite *sprite) { StartFieldEffectForEventObject(FLDEFF_HOT_SPRINGS_WATER, eventObj); } -void GroundEffect_Seaweed(struct MapObject *eventObj, struct Sprite *sprite) +void GroundEffect_Seaweed(struct EventObject *eventObj, struct Sprite *sprite) { gFieldEffectArguments[0] = eventObj->currentCoords.x; gFieldEffectArguments[1] = eventObj->currentCoords.y; FieldEffectStart(FLDEFF_BUBBLES); } -static void (*const sGroundEffectFuncs[])(struct MapObject *eventObj, struct Sprite *sprite) = { +static void (*const sGroundEffectFuncs[])(struct EventObject *eventObj, struct Sprite *sprite) = { GroundEffect_SpawnOnTallGrass, GroundEffect_StepOnTallGrass, GroundEffect_SpawnOnLongGrass, @@ -6669,11 +6667,11 @@ static void (*const sGroundEffectFuncs[])(struct MapObject *eventObj, struct Spr GroundEffect_Seaweed }; -/*static*/ void DoFlaggedGroundEffects(struct MapObject *eventObj, struct Sprite *sprite, u32 flags) +/*static*/ void DoFlaggedGroundEffects(struct EventObject *eventObj, struct Sprite *sprite, u32 flags) { u8 i; - if (FieldObjectIsFarawayIslandMew(eventObj) == TRUE && !sub_81D4A58(eventObj)) + if (EventObjectIsFarawayIslandMew(eventObj) == TRUE && !sub_81D4A58(eventObj)) return; for (i = 0; i < ARRAY_COUNT(sGroundEffectFuncs); i++, flags >>= 1) @@ -6681,7 +6679,7 @@ static void (*const sGroundEffectFuncs[])(struct MapObject *eventObj, struct Spr sGroundEffectFuncs[i](eventObj, sprite); } -void filters_out_some_ground_effects(struct MapObject *eventObj, u32 *flags) +void filters_out_some_ground_effects(struct EventObject *eventObj, u32 *flags) { if (eventObj->disableCoveringGroundEffects) { @@ -6697,38 +6695,38 @@ void filters_out_some_ground_effects(struct MapObject *eventObj, u32 *flags) } } -void FilterOutStepOnPuddleGroundEffectIfJumping(struct MapObject *eventObj, u32 *flags) +void FilterOutStepOnPuddleGroundEffectIfJumping(struct EventObject *eventObj, u32 *flags) { if (eventObj->landingJump) *flags &= ~GROUND_EFFECT_FLAG_PUDDLE; } -static void DoGroundEffects_OnSpawn(struct MapObject *eventObj, struct Sprite *sprite) +static void DoGroundEffects_OnSpawn(struct EventObject *eventObj, struct Sprite *sprite) { u32 flags; if (eventObj->triggerGroundEffectsOnMove) { flags = 0; - FieldObjectUpdateZCoordAndPriority(eventObj, sprite); + EventObjectUpdateZCoordAndPriority(eventObj, sprite); GetAllGroundEffectFlags_OnSpawn(eventObj, &flags); - FieldObjectSetSpriteOamTableForLongGrass(eventObj, sprite); + EventObjectSetSpriteOamTableForLongGrass(eventObj, sprite); DoFlaggedGroundEffects(eventObj, sprite, flags); eventObj->triggerGroundEffectsOnMove = 0; eventObj->disableCoveringGroundEffects = 0; } } -static void DoGroundEffects_OnBeginStep(struct MapObject *eventObj, struct Sprite *sprite) +static void DoGroundEffects_OnBeginStep(struct EventObject *eventObj, struct Sprite *sprite) { u32 flags; if (eventObj->triggerGroundEffectsOnMove) { flags = 0; - FieldObjectUpdateZCoordAndPriority(eventObj, sprite); + EventObjectUpdateZCoordAndPriority(eventObj, sprite); GetAllGroundEffectFlags_OnBeginStep(eventObj, &flags); - FieldObjectSetSpriteOamTableForLongGrass(eventObj, sprite); + EventObjectSetSpriteOamTableForLongGrass(eventObj, sprite); filters_out_some_ground_effects(eventObj, &flags); DoFlaggedGroundEffects(eventObj, sprite, flags); eventObj->triggerGroundEffectsOnMove = 0; @@ -6736,16 +6734,16 @@ static void DoGroundEffects_OnBeginStep(struct MapObject *eventObj, struct Sprit } } -static void DoGroundEffects_OnFinishStep(struct MapObject *eventObj, struct Sprite *sprite) +static void DoGroundEffects_OnFinishStep(struct EventObject *eventObj, struct Sprite *sprite) { u32 flags; if (eventObj->triggerGroundEffectsOnStop) { flags = 0; - FieldObjectUpdateZCoordAndPriority(eventObj, sprite); + EventObjectUpdateZCoordAndPriority(eventObj, sprite); GetAllGroundEffectFlags_OnFinishStep(eventObj, &flags); - FieldObjectSetSpriteOamTableForLongGrass(eventObj, sprite); + EventObjectSetSpriteOamTableForLongGrass(eventObj, sprite); FilterOutStepOnPuddleGroundEffectIfJumping(eventObj, &flags); DoFlaggedGroundEffects(eventObj, sprite, flags); eventObj->triggerGroundEffectsOnStop = 0; @@ -6753,55 +6751,55 @@ static void DoGroundEffects_OnFinishStep(struct MapObject *eventObj, struct Spri } } -bool8 FreezeMapObject(struct MapObject *mapObject) +bool8 FreezeEventObject(struct EventObject *eventObject) { - if (mapObject->heldMovementActive || mapObject->frozen) + if (eventObject->heldMovementActive || eventObject->frozen) { return TRUE; } else { - mapObject->frozen = 1; - mapObject->spriteAnimPausedBackup = gSprites[mapObject->spriteId].animPaused; - mapObject->spriteAffineAnimPausedBackup = gSprites[mapObject->spriteId].affineAnimPaused; - gSprites[mapObject->spriteId].animPaused = 1; - gSprites[mapObject->spriteId].affineAnimPaused = 1; + eventObject->frozen = 1; + eventObject->spriteAnimPausedBackup = gSprites[eventObject->spriteId].animPaused; + eventObject->spriteAffineAnimPausedBackup = gSprites[eventObject->spriteId].affineAnimPaused; + gSprites[eventObject->spriteId].animPaused = 1; + gSprites[eventObject->spriteId].affineAnimPaused = 1; return FALSE; } } -void FreezeMapObjects(void) +void FreezeEventObjects(void) { u8 i; - for (i = 0; i < MAP_OBJECTS_COUNT; i++) - if (gMapObjects[i].active && i != gPlayerAvatar.mapObjectId) - FreezeMapObject(&gMapObjects[i]); + for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + if (gEventObjects[i].active && i != gPlayerAvatar.eventObjectId) + FreezeEventObject(&gEventObjects[i]); } -void FreezeMapObjectsExceptOne(u8 a1) +void FreezeEventObjectsExceptOne(u8 a1) { u8 i; - for (i = 0; i < MAP_OBJECTS_COUNT; i++) - if (i != a1 && gMapObjects[i].active && i != gPlayerAvatar.mapObjectId) - FreezeMapObject(&gMapObjects[i]); + for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + if (i != a1 && gEventObjects[i].active && i != gPlayerAvatar.eventObjectId) + FreezeEventObject(&gEventObjects[i]); } -void npc_sync_anim_pause_bits(struct MapObject *mapObject) +void npc_sync_anim_pause_bits(struct EventObject *eventObject) { - if (mapObject->active && mapObject->frozen) + if (eventObject->active && eventObject->frozen) { - mapObject->frozen = 0; - gSprites[mapObject->spriteId].animPaused = mapObject->spriteAnimPausedBackup; - gSprites[mapObject->spriteId].affineAnimPaused = mapObject->spriteAffineAnimPausedBackup; + eventObject->frozen = 0; + gSprites[eventObject->spriteId].animPaused = eventObject->spriteAnimPausedBackup; + gSprites[eventObject->spriteId].affineAnimPaused = eventObject->spriteAffineAnimPausedBackup; } } -void UnfreezeMapObjects(void) +void UnfreezeEventObjects(void) { u8 i; - for (i = 0; i < MAP_OBJECTS_COUNT; i++) - if (gMapObjects[i].active) - npc_sync_anim_pause_bits(&gMapObjects[i]); + for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + if (gEventObjects[i].active) + npc_sync_anim_pause_bits(&gEventObjects[i]); } void little_step(struct Sprite *sprite, u8 dir) @@ -7126,12 +7124,12 @@ u8 sub_80978E4(struct Sprite *sprite) return v2; } -void SetFieldObjectStepTimer(struct Sprite *sprite, s16 timer) +void SetEventObjectStepTimer(struct Sprite *sprite, s16 timer) { sprite->data[3] = timer; } -bool8 RunFieldObjectStepTimer(struct Sprite *sprite) +bool8 RunEventObjectStepTimer(struct Sprite *sprite) { sprite->data[3]--; @@ -7220,7 +7218,7 @@ void sub_8097B78(u8 var1, u8 var2) u8 spriteId = sub_8097B2C(var1); if(spriteId != MAX_SPRITES) - StartSpriteAnim(&gSprites[spriteId], FieldObjectDirectionToImageAnimId(var2)); + StartSpriteAnim(&gSprites[spriteId], EventObjectDirectionToImageAnimId(var2)); } void sub_8097BB4(u8 var1, u8 var2) @@ -7230,7 +7228,7 @@ void sub_8097BB4(u8 var1, u8 var2) if(spriteId != MAX_SPRITES) { struct Sprite *sprite = &gSprites[spriteId]; - const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(var2); + const struct EventObjectGraphicsInfo *gfxInfo = GetEventObjectGraphicsInfo(var2); u16 tileNum = sprite->oam.tileNum; sprite->oam = *gfxInfo->oam; @@ -7354,24 +7352,24 @@ bool32 sub_8097D9C(u8 var) return FALSE; } -u32 StartFieldEffectForEventObject(u8 fieldEffectId, struct MapObject *mapObject) +u32 StartFieldEffectForEventObject(u8 fieldEffectId, struct EventObject *eventObject) { - FieldObjectGetLocalIdAndMap(mapObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); return FieldEffectStart(fieldEffectId); } -void DoShadowFieldEffect(struct MapObject *mapObject) +void DoShadowFieldEffect(struct EventObject *eventObject) { - if (!mapObject->hasShadow) + if (!eventObject->hasShadow) { - mapObject->hasShadow = 1; - StartFieldEffectForEventObject(FLDEFF_SHADOW, mapObject); + eventObject->hasShadow = 1; + StartFieldEffectForEventObject(FLDEFF_SHADOW, eventObject); } } -static void DoRippleFieldEffect(struct MapObject *mapObject, struct Sprite *sprite) +static void DoRippleFieldEffect(struct EventObject *eventObject, struct Sprite *sprite) { - const struct MapObjectGraphicsInfo *gfxInfo = GetFieldObjectGraphicsInfo(mapObject->graphicsId); + const struct EventObjectGraphicsInfo *gfxInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); gFieldEffectArguments[0] = sprite->pos1.x; gFieldEffectArguments[1] = sprite->pos1.y + (gfxInfo->height >> 1) - 2; gFieldEffectArguments[2] = 151; @@ -7379,36 +7377,36 @@ static void DoRippleFieldEffect(struct MapObject *mapObject, struct Sprite *spri FieldEffectStart(FLDEFF_RIPPLE); } -u8 (*const gUnknown_0850E854[])(struct MapObject *, struct Sprite *) = { +u8 (*const gUnknown_0850E854[])(struct EventObject *, struct Sprite *) = { sub_8097E50, sub_80964B8, }; -u8 (*const gUnknown_0850E85C[])(struct MapObject *, struct Sprite *) = { +u8 (*const gUnknown_0850E85C[])(struct EventObject *, struct Sprite *) = { sub_8097EF0, sub_80964B8, }; -u8 (*const gUnknown_0850E864[])(struct MapObject *, struct Sprite *) = { +u8 (*const gUnknown_0850E864[])(struct EventObject *, struct Sprite *) = { sub_80980C0, sub_80980D0, sub_8098124, }; -u8 (*const gUnknown_0850E870[])(struct MapObject *, struct Sprite *) = { +u8 (*const gUnknown_0850E870[])(struct EventObject *, struct Sprite *) = { sub_80980F4, sub_8098108, sub_8098124, }; -u8 sub_8097E50(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_8097E50(struct EventObject *eventObject, struct Sprite *sprite) { u32 one; bool32 ableToStore = FALSE; if (gUnknown_020375B8 == NULL) { gUnknown_020375B8 = AllocZeroed(0x14); - gUnknown_020375B8[0] = mapObject->localId; + gUnknown_020375B8[0] = eventObject->localId; // needed to match gUnknown_020375B8[16] = (one = 1); ableToStore = one; @@ -7423,7 +7421,7 @@ u8 sub_8097E50(struct MapObject *mapObject, struct Sprite *sprite) if (firstFreeSlot == 16 && gUnknown_020375B8[i] == 0) firstFreeSlot = i; - if (gUnknown_020375B8[i] == mapObject->localId) + if (gUnknown_020375B8[i] == eventObject->localId) { found = TRUE; break; @@ -7432,7 +7430,7 @@ u8 sub_8097E50(struct MapObject *mapObject, struct Sprite *sprite) if (!found && firstFreeSlot != 16) { - gUnknown_020375B8[firstFreeSlot] = mapObject->localId; + gUnknown_020375B8[firstFreeSlot] = eventObject->localId; gUnknown_020375B8[16]++; ableToStore = TRUE; } @@ -7440,15 +7438,15 @@ u8 sub_8097E50(struct MapObject *mapObject, struct Sprite *sprite) if (ableToStore == TRUE) { - mapObject->inanimate = TRUE; - mapObject->facingDirectionLocked = TRUE; + eventObject->inanimate = TRUE; + eventObject->facingDirectionLocked = TRUE; } sprite->data[2] = 1; return TRUE; } -u8 sub_8097EF0(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_8097EF0(struct EventObject *eventObject, struct Sprite *sprite) { bool32 ableToStore; u8 id; @@ -7457,7 +7455,7 @@ u8 sub_8097EF0(struct MapObject *mapObject, struct Sprite *sprite) if (gUnknown_020375B8 != NULL) { ableToStore = FALSE; - id = sub_8097F78(mapObject); + id = sub_8097F78(eventObject); if (id != 16) { gUnknown_020375B8[id] = 0; @@ -7468,8 +7466,8 @@ u8 sub_8097EF0(struct MapObject *mapObject, struct Sprite *sprite) FREE_AND_SET_NULL(gUnknown_020375B8); if (ableToStore == TRUE) { - mapObject->inanimate = GetFieldObjectGraphicsInfo(mapObject->graphicsId)->inanimate; - mapObject->facingDirectionLocked = 0; + eventObject->inanimate = GetEventObjectGraphicsInfo(eventObject->graphicsId)->inanimate; + eventObject->facingDirectionLocked = 0; sprite->animPaused = 0; } } @@ -7477,36 +7475,36 @@ u8 sub_8097EF0(struct MapObject *mapObject, struct Sprite *sprite) return TRUE; } -u8 sub_8097F78(struct MapObject *mapObject) +u8 sub_8097F78(struct EventObject *eventObject) { u8 i; - for(i = 0; i < MAP_OBJECTS_COUNT; i++) + for(i = 0; i < EVENT_OBJECTS_COUNT; i++) { - if(gUnknown_020375B8[i] == mapObject->localId) + if(gUnknown_020375B8[i] == eventObject->localId) return i; } - return MAP_OBJECTS_COUNT; + return EVENT_OBJECTS_COUNT; } -void sub_8097FA4(struct MapObject *mapObject) +void sub_8097FA4(struct EventObject *eventObject) { u8 taskId = CreateTask(sub_8097FE4, 0xFF); struct Task *task = &gTasks[taskId]; - StoreWordInTwoHalfwords(&task->data[0], (u32)mapObject); - mapObject->warpArrowSpriteId = taskId; + StoreWordInTwoHalfwords(&task->data[0], (u32)eventObject); + eventObject->warpArrowSpriteId = taskId; task->data[3] = 0xFFFF; } static void sub_8097FE4(u8 taskId) { - struct MapObject *mapObject; + struct EventObject *eventObject; struct Sprite *sprite; struct Task *task = &gTasks[taskId]; - LoadWordFromTwoHalfwords(&task->data[0], (u32 *)&mapObject); // load the map object pointer. - sprite = &gSprites[mapObject->spriteId]; + LoadWordFromTwoHalfwords(&task->data[0], (u32 *)&eventObject); // load the map object pointer. + sprite = &gSprites[eventObject->spriteId]; if(!(task->data[2] & 0x3)) sprite->pos2.y += task->data[3]; @@ -7530,22 +7528,22 @@ void sub_8098074(u8 var1, u8 var2) { u8 i; - for(i = 0; i < MAP_OBJECTS_COUNT; i++) + for(i = 0; i < EVENT_OBJECTS_COUNT; i++) { if(i != var1 && i != var2 && - gMapObjects[i].active && i != gPlayerAvatar.mapObjectId) - FreezeMapObject(&gMapObjects[i]); + gEventObjects[i].active && i != gPlayerAvatar.eventObjectId) + FreezeEventObject(&gEventObjects[i]); } } -u8 sub_80980C0(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_80980C0(struct EventObject *eventObject, struct Sprite *sprite) { sprite->pos2.y = 0; sprite->data[2]++; return FALSE; } -u8 sub_80980D0(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_80980D0(struct EventObject *eventObject, struct Sprite *sprite) { sprite->pos2.y -= 8; @@ -7554,14 +7552,14 @@ u8 sub_80980D0(struct MapObject *mapObject, struct Sprite *sprite) return FALSE; } -u8 sub_80980F4(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_80980F4(struct EventObject *eventObject, struct Sprite *sprite) { sprite->pos2.y = -160; sprite->data[2]++; return FALSE; } -u8 sub_8098108(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_8098108(struct EventObject *eventObject, struct Sprite *sprite) { sprite->pos2.y += 8; @@ -7571,7 +7569,7 @@ u8 sub_8098108(struct MapObject *mapObject, struct Sprite *sprite) } // though this function returns TRUE without doing anything, this header is required due to being in an array of functions which needs it. -u8 sub_8098124(struct MapObject *mapObject, struct Sprite *sprite) +u8 sub_8098124(struct EventObject *eventObject, struct Sprite *sprite) { return TRUE; } |