diff options
Diffstat (limited to 'src/event_object_movement.c')
| -rw-r--r-- | src/event_object_movement.c | 4512 |
1 files changed, 2256 insertions, 2256 deletions
diff --git a/src/event_object_movement.c b/src/event_object_movement.c index 743d9bb92..c6ce76195 100644 --- a/src/event_object_movement.c +++ b/src/event_object_movement.c @@ -20,32 +20,32 @@ // this file was known as evobjmv.c in Game Freak's original source -static u8 MovementType_BerryTreeGrowth_Callback(struct EventObject*, struct Sprite*); -static u8 MovementType_Disguise_Callback(struct EventObject*, struct Sprite*); -static u8 MovementType_Hidden_Callback(struct EventObject*, struct Sprite*); -static bool8 IsCoordOutsideEventObjectMovementRange(struct EventObject*, s16, s16); -static bool8 DoesObjectCollideWithObjectAt(struct EventObject*, s16, s16); -static bool8 IsMetatileDirectionallyImpassable(struct EventObject*, s16, s16, u8); -static void ClearEventObjectMovement(struct EventObject*, struct Sprite *sprite); -static void EventObjectSetSingleMovement(struct EventObject*, struct Sprite*, u8); -static u8 EventObjectExecSingleMovementAction(struct EventObject*, struct Sprite*); +static u8 MovementType_BerryTreeGrowth_Callback(struct ObjectEvent*, struct Sprite*); +static u8 MovementType_Disguise_Callback(struct ObjectEvent*, struct Sprite*); +static u8 MovementType_Hidden_Callback(struct ObjectEvent*, struct Sprite*); +static bool8 IsCoordOutsideObjectEventMovementRange(struct ObjectEvent*, s16, s16); +static bool8 DoesObjectCollideWithObjectAt(struct ObjectEvent*, s16, s16); +static bool8 IsMetatileDirectionallyImpassable(struct ObjectEvent*, s16, s16, u8); +static void ClearObjectEventMovement(struct ObjectEvent*, struct Sprite *sprite); +static void ObjectEventSetSingleMovement(struct ObjectEvent*, struct Sprite*, u8); +static u8 ObjectEventExecSingleMovementAction(struct ObjectEvent*, struct Sprite*); static void SetMovementDelay(struct Sprite*, s16); static u8 WaitForMovementDelay(struct Sprite*); -static u8 GetCollisionInDirection(struct EventObject*, u8); +static u8 GetCollisionInDirection(struct ObjectEvent*, u8); static void MoveCoordsInDirection(u32, s16 *, s16 *, s16, s16); -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 UpdateEventObjectSpriteAnimPause(struct EventObject*, struct Sprite*); -static void TryEnableEventObjectAnim(struct EventObject*, struct Sprite*); -static void EventObjectExecHeldMovementAction(struct EventObject*, struct Sprite*); -static void EventObjectUpdateSubpriority(struct EventObject*, struct Sprite*); -static void UpdateEventObjectVisibility(struct EventObject*, struct Sprite*); -static void UpdateEventObjectIsOffscreen(struct EventObject*, struct Sprite*); -static void UpdateEventObjSpriteVisibility(struct EventObject*, struct Sprite*); -static void nullsub(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 DoGroundEffects_OnSpawn(struct ObjectEvent*, struct Sprite*); +static void DoGroundEffects_OnBeginStep(struct ObjectEvent*, struct Sprite*); +static void DoGroundEffects_OnFinishStep(struct ObjectEvent*, struct Sprite*); +static void UpdateObjectEventSpriteAnimPause(struct ObjectEvent*, struct Sprite*); +static void TryEnableObjectEventAnim(struct ObjectEvent*, struct Sprite*); +static void ObjectEventExecHeldMovementAction(struct ObjectEvent*, struct Sprite*); +static void ObjectEventUpdateSubpriority(struct ObjectEvent*, struct Sprite*); +static void UpdateObjectEventVisibility(struct ObjectEvent*, struct Sprite*); +static void UpdateObjectEventIsOffscreen(struct ObjectEvent*, struct Sprite*); +static void UpdateObjEventSpriteVisibility(struct ObjectEvent*, struct Sprite*); +static void nullsub(struct ObjectEvent*, struct Sprite*, u8); +static void DoTracksGroundEffect_Footprints(struct ObjectEvent*, struct Sprite*, u8); +static void DoTracksGroundEffect_BikeTireTracks(struct ObjectEvent*, struct Sprite*, u8); static u8 GetReflectionTypeByMetatileBehavior(u32); static void Step1(struct Sprite *sprite, u8 direction); static void Step2(struct Sprite *sprite, u8 direction); @@ -57,41 +57,41 @@ static void CameraObject_0(struct Sprite *); static void CameraObject_1(struct Sprite *); static void CameraObject_2(struct Sprite *); static void ObjectCB_CameraObject(struct Sprite *sprite); -static bool8 EventObjectDoesZCoordMatch(struct EventObject *, u8); -static struct EventObjectTemplate *FindEventObjectTemplateByLocalId(u8, struct EventObjectTemplate*, u8); -static void UpdateEventObjectSpriteSubpriorityAndVisibility(struct Sprite *); +static bool8 ObjectEventDoesZCoordMatch(struct ObjectEvent *, u8); +static struct ObjectEventTemplate *FindObjectEventTemplateByLocalId(u8, struct ObjectEventTemplate*, u8); +static void UpdateObjectEventSpriteSubpriorityAndVisibility(struct Sprite *); static void InitObjectPriorityByZCoord(struct Sprite *sprite, u8 z); static void CreateReflectionEffectSprites(void); -static u8 GetEventObjectIdByLocalIdAndMapInternal(u8, u8, u8); -static u8 GetEventObjectIdByLocalId(u8); -static void RemoveEventObjectInternal(struct EventObject *); -static void MakeObjectTemplateFromEventObjectTemplate(struct EventObjectTemplate *eventObjTemplate, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables); -static void RemoveEventObjectIfOutsideView(struct EventObject *eventObject); -static void SetPlayerAvatarEventObjectIdAndObjectId(u8, u8); -static void sub_805B914(struct EventObject *); +static u8 GetObjectEventIdByLocalIdAndMapInternal(u8, u8, u8); +static u8 GetObjectEventIdByLocalId(u8); +static void RemoveObjectEventInternal(struct ObjectEvent *); +static void MakeObjectTemplateFromObjectEventTemplate(struct ObjectEventTemplate *objEventTemplate, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables); +static void RemoveObjectEventIfOutsideView(struct ObjectEvent *objectEvent); +static void SetPlayerAvatarObjectEventIdAndObjectId(u8, u8); +static void sub_805B914(struct ObjectEvent *); static u8 sub_805BE58(const struct SpritePalette *); -static bool8 GetAvailableEventObjectId(u16, u8, u8, u8 *); -static void SetEventObjectDynamicGraphicsId(struct EventObject *); -static u8 FindEventObjectPaletteIndexByTag(u16); -static u16 GetEventObjectFlagIdByEventObjectId(u8); -static void GetEventObjectMovingCameraOffset(s16 *, s16 *); -static void EventObjectUpdateMetatileBehaviors(struct EventObject *); -static void GetGroundEffectFlags_Reflection(struct EventObject *, u32 *); -static void GetGroundEffectFlags_TallGrassOnSpawn(struct EventObject *, u32 *); -static void GetGroundEffectFlags_TallGrassOnBeginStep(struct EventObject *, u32 *); -static void GetGroundEffectFlags_LongGrassOnSpawn(struct EventObject *, u32 *); -static void GetGroundEffectFlags_LongGrassOnBeginStep(struct EventObject *, u32 *); -static void GetGroundEffectFlags_Tracks(struct EventObject *, u32 *); -static void GetGroundEffectFlags_SandPile(struct EventObject *, u32 *); -static void GetGroundEffectFlags_ShallowFlowingWater(struct EventObject *, u32 *); -static void GetGroundEffectFlags_Puddle(struct EventObject *, u32 *); -static void GetGroundEffectFlags_Ripple(struct EventObject *, u32 *); -static void GetGroundEffectFlags_ShortGrass(struct EventObject *, u32 *); -static void GetGroundEffectFlags_HotSprings(struct EventObject *, u32 *); -static void GetGroundEffectFlags_Seaweed(struct EventObject *, u32 *); -static void GetGroundEffectFlags_JumpLanding(struct EventObject *, u32 *); -static u8 EventObjectCheckForReflectiveSurface(struct EventObject *); -static void DoRippleFieldEffect(struct EventObject *eventObj, struct Sprite *sprite); +static bool8 GetAvailableObjectEventId(u16, u8, u8, u8 *); +static void SetObjectEventDynamicGraphicsId(struct ObjectEvent *); +static u8 FindObjectEventPaletteIndexByTag(u16); +static u16 GetObjectEventFlagIdByObjectEventId(u8); +static void GetObjectEventMovingCameraOffset(s16 *, s16 *); +static void ObjectEventUpdateMetatileBehaviors(struct ObjectEvent *); +static void GetGroundEffectFlags_Reflection(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_TallGrassOnSpawn(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_TallGrassOnBeginStep(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_LongGrassOnSpawn(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_LongGrassOnBeginStep(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_Tracks(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_SandPile(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_ShallowFlowingWater(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_Puddle(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_Ripple(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_ShortGrass(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_HotSprings(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_Seaweed(struct ObjectEvent *, u32 *); +static void GetGroundEffectFlags_JumpLanding(struct ObjectEvent *, u32 *); +static u8 ObjectEventCheckForReflectiveSurface(struct ObjectEvent *); +static void DoRippleFieldEffect(struct ObjectEvent *objEvent, struct Sprite *sprite); const u8 gReflectionEffectPaletteMap[] = {1, 1, 6, 7, 8, 9, 6, 7, 8, 9, 11, 11, 0, 0, 0, 0}; @@ -103,8 +103,8 @@ void (*const gCameraObjectFuncs[])(struct Sprite *) = { CameraObject_2, }; -#include "data/field_event_obj/event_object_graphics.h" -#include "data/field_event_obj/field_effect_object_graphics.h" +#include "data/object_event/event_object_graphics.h" +#include "data/object_event/field_effect_object_graphics.h" // movement type callbacks static void (*const sMovementTypeCallbacks[])(struct Sprite *) = @@ -348,240 +348,240 @@ const u8 gInitialMovementTypeFacingDirections[] = { DIR_SOUTH, // MOVEMENT_TYPE_INVISIBLE }; -#define EVENT_OBJ_PAL_TAG_0 0x1103 -#define EVENT_OBJ_PAL_TAG_1 0x1104 -#define EVENT_OBJ_PAL_TAG_2 0x1105 -#define EVENT_OBJ_PAL_TAG_3 0x1106 -#define EVENT_OBJ_PAL_TAG_4 0x1107 -#define EVENT_OBJ_PAL_TAG_5 0x1108 -#define EVENT_OBJ_PAL_TAG_6 0x1109 -#define EVENT_OBJ_PAL_TAG_7 0x110A -#define EVENT_OBJ_PAL_TAG_8 0x1100 -#define EVENT_OBJ_PAL_TAG_9 0x1101 -#define EVENT_OBJ_PAL_TAG_10 0x1102 -#define EVENT_OBJ_PAL_TAG_11 0x1115 -#define EVENT_OBJ_PAL_TAG_12 0x110B -#define EVENT_OBJ_PAL_TAG_13 0x110C -#define EVENT_OBJ_PAL_TAG_14 0x110D -#define EVENT_OBJ_PAL_TAG_15 0x110E -#define EVENT_OBJ_PAL_TAG_16 0x110F -#define EVENT_OBJ_PAL_TAG_17 0x1110 -#define EVENT_OBJ_PAL_TAG_18 0x1111 -#define EVENT_OBJ_PAL_TAG_19 0x1112 -#define EVENT_OBJ_PAL_TAG_20 0x1113 -#define EVENT_OBJ_PAL_TAG_21 0x1114 -#define EVENT_OBJ_PAL_TAG_22 0x1116 -#define EVENT_OBJ_PAL_TAG_23 0x1117 -#define EVENT_OBJ_PAL_TAG_24 0x1118 -#define EVENT_OBJ_PAL_TAG_25 0x1119 -#define EVENT_OBJ_PAL_TAG_26 0x111A - -#define EVENT_OBJ_PAL_TAG_NONE 0x11FF - -#include "data/field_event_obj/event_object_graphics_info_pointers.h" -#include "data/field_event_obj/field_effect_object_template_pointers.h" -#include "data/field_event_obj/event_object_pic_tables.h" -#include "data/field_event_obj/event_object_anims.h" -#include "data/field_event_obj/base_oam.h" -#include "data/field_event_obj/event_object_subsprites.h" -#include "data/field_event_obj/event_object_graphics_info.h" - -const struct SpritePalette sEventObjectSpritePalettes[] = { - {gEventObjectPalette0, EVENT_OBJ_PAL_TAG_0}, - {gEventObjectPalette1, EVENT_OBJ_PAL_TAG_1}, - {gEventObjectPalette2, EVENT_OBJ_PAL_TAG_2}, - {gEventObjectPalette3, EVENT_OBJ_PAL_TAG_3}, - {gEventObjectPalette4, EVENT_OBJ_PAL_TAG_4}, - {gEventObjectPalette5, EVENT_OBJ_PAL_TAG_5}, - {gEventObjectPalette6, EVENT_OBJ_PAL_TAG_6}, - {gEventObjectPalette7, EVENT_OBJ_PAL_TAG_7}, - {gEventObjectPalette8, EVENT_OBJ_PAL_TAG_8}, - {gEventObjectPalette9, EVENT_OBJ_PAL_TAG_9}, - {gEventObjectPalette10, EVENT_OBJ_PAL_TAG_10}, - {gEventObjectPalette11, EVENT_OBJ_PAL_TAG_11}, - {gEventObjectPalette12, EVENT_OBJ_PAL_TAG_12}, - {gEventObjectPalette13, EVENT_OBJ_PAL_TAG_13}, - {gEventObjectPalette14, EVENT_OBJ_PAL_TAG_14}, - {gEventObjectPalette15, EVENT_OBJ_PAL_TAG_15}, - {gEventObjectPalette16, EVENT_OBJ_PAL_TAG_16}, - {gEventObjectPalette17, EVENT_OBJ_PAL_TAG_17}, - {gEventObjectPalette18, EVENT_OBJ_PAL_TAG_18}, - {gEventObjectPalette19, EVENT_OBJ_PAL_TAG_19}, - {gEventObjectPalette20, EVENT_OBJ_PAL_TAG_20}, - {gEventObjectPalette21, EVENT_OBJ_PAL_TAG_21}, - {gEventObjectPalette22, EVENT_OBJ_PAL_TAG_22}, - {gEventObjectPalette23, EVENT_OBJ_PAL_TAG_23}, - {gEventObjectPalette24, EVENT_OBJ_PAL_TAG_24}, - {gEventObjectPalette25, EVENT_OBJ_PAL_TAG_25}, - {gEventObjectPalette26, EVENT_OBJ_PAL_TAG_26}, +#define OBJ_EVENT_PAL_TAG_0 0x1103 +#define OBJ_EVENT_PAL_TAG_1 0x1104 +#define OBJ_EVENT_PAL_TAG_2 0x1105 +#define OBJ_EVENT_PAL_TAG_3 0x1106 +#define OBJ_EVENT_PAL_TAG_4 0x1107 +#define OBJ_EVENT_PAL_TAG_5 0x1108 +#define OBJ_EVENT_PAL_TAG_6 0x1109 +#define OBJ_EVENT_PAL_TAG_7 0x110A +#define OBJ_EVENT_PAL_TAG_8 0x1100 +#define OBJ_EVENT_PAL_TAG_9 0x1101 +#define OBJ_EVENT_PAL_TAG_10 0x1102 +#define OBJ_EVENT_PAL_TAG_11 0x1115 +#define OBJ_EVENT_PAL_TAG_12 0x110B +#define OBJ_EVENT_PAL_TAG_13 0x110C +#define OBJ_EVENT_PAL_TAG_14 0x110D +#define OBJ_EVENT_PAL_TAG_15 0x110E +#define OBJ_EVENT_PAL_TAG_16 0x110F +#define OBJ_EVENT_PAL_TAG_17 0x1110 +#define OBJ_EVENT_PAL_TAG_18 0x1111 +#define OBJ_EVENT_PAL_TAG_19 0x1112 +#define OBJ_EVENT_PAL_TAG_20 0x1113 +#define OBJ_EVENT_PAL_TAG_21 0x1114 +#define OBJ_EVENT_PAL_TAG_22 0x1116 +#define OBJ_EVENT_PAL_TAG_23 0x1117 +#define OBJ_EVENT_PAL_TAG_24 0x1118 +#define OBJ_EVENT_PAL_TAG_25 0x1119 +#define OBJ_EVENT_PAL_TAG_26 0x111A + +#define OBJ_EVENT_PAL_TAG_NONE 0x11FF + +#include "data/object_event/event_object_graphics_info_pointers.h" +#include "data/object_event/field_effect_object_template_pointers.h" +#include "data/object_event/event_object_pic_tables.h" +#include "data/object_event/event_object_anims.h" +#include "data/object_event/base_oam.h" +#include "data/object_event/event_object_subsprites.h" +#include "data/object_event/event_object_graphics_info.h" + +const struct SpritePalette sObjectEventSpritePalettes[] = { + {gObjectEventPalette0, OBJ_EVENT_PAL_TAG_0}, + {gObjectEventPalette1, OBJ_EVENT_PAL_TAG_1}, + {gObjectEventPalette2, OBJ_EVENT_PAL_TAG_2}, + {gObjectEventPalette3, OBJ_EVENT_PAL_TAG_3}, + {gObjectEventPalette4, OBJ_EVENT_PAL_TAG_4}, + {gObjectEventPalette5, OBJ_EVENT_PAL_TAG_5}, + {gObjectEventPalette6, OBJ_EVENT_PAL_TAG_6}, + {gObjectEventPalette7, OBJ_EVENT_PAL_TAG_7}, + {gObjectEventPalette8, OBJ_EVENT_PAL_TAG_8}, + {gObjectEventPalette9, OBJ_EVENT_PAL_TAG_9}, + {gObjectEventPalette10, OBJ_EVENT_PAL_TAG_10}, + {gObjectEventPalette11, OBJ_EVENT_PAL_TAG_11}, + {gObjectEventPalette12, OBJ_EVENT_PAL_TAG_12}, + {gObjectEventPalette13, OBJ_EVENT_PAL_TAG_13}, + {gObjectEventPalette14, OBJ_EVENT_PAL_TAG_14}, + {gObjectEventPalette15, OBJ_EVENT_PAL_TAG_15}, + {gObjectEventPalette16, OBJ_EVENT_PAL_TAG_16}, + {gObjectEventPalette17, OBJ_EVENT_PAL_TAG_17}, + {gObjectEventPalette18, OBJ_EVENT_PAL_TAG_18}, + {gObjectEventPalette19, OBJ_EVENT_PAL_TAG_19}, + {gObjectEventPalette20, OBJ_EVENT_PAL_TAG_20}, + {gObjectEventPalette21, OBJ_EVENT_PAL_TAG_21}, + {gObjectEventPalette22, OBJ_EVENT_PAL_TAG_22}, + {gObjectEventPalette23, OBJ_EVENT_PAL_TAG_23}, + {gObjectEventPalette24, OBJ_EVENT_PAL_TAG_24}, + {gObjectEventPalette25, OBJ_EVENT_PAL_TAG_25}, + {gObjectEventPalette26, OBJ_EVENT_PAL_TAG_26}, {NULL, 0x0000}, }; const u16 gPlayerReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_9, - EVENT_OBJ_PAL_TAG_9, - EVENT_OBJ_PAL_TAG_9, - EVENT_OBJ_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_9, }; // These were probably intended to be used for the female player's reflection. const u16 gUnusedPlayerReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_18, - EVENT_OBJ_PAL_TAG_18, - EVENT_OBJ_PAL_TAG_18, - EVENT_OBJ_PAL_TAG_18, + OBJ_EVENT_PAL_TAG_18, + OBJ_EVENT_PAL_TAG_18, + OBJ_EVENT_PAL_TAG_18, + OBJ_EVENT_PAL_TAG_18, }; const u16 gPlayerUnderwaterReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_11, - EVENT_OBJ_PAL_TAG_11, - EVENT_OBJ_PAL_TAG_11, - EVENT_OBJ_PAL_TAG_11, + OBJ_EVENT_PAL_TAG_11, + OBJ_EVENT_PAL_TAG_11, + OBJ_EVENT_PAL_TAG_11, + OBJ_EVENT_PAL_TAG_11, }; const struct ReflectionPaletteSet gPlayerReflectionPaletteSets[] = { - {EVENT_OBJ_PAL_TAG_8, gPlayerReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_17, gPlayerReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_11, gPlayerUnderwaterReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_NONE, NULL}, + {OBJ_EVENT_PAL_TAG_8, gPlayerReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_17, gPlayerReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_11, gPlayerUnderwaterReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_NONE, NULL}, }; const u16 gQuintyPlumpReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_13, - EVENT_OBJ_PAL_TAG_13, - EVENT_OBJ_PAL_TAG_13, - EVENT_OBJ_PAL_TAG_13, + OBJ_EVENT_PAL_TAG_13, + OBJ_EVENT_PAL_TAG_13, + OBJ_EVENT_PAL_TAG_13, + OBJ_EVENT_PAL_TAG_13, }; const u16 gTruckReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_14, - EVENT_OBJ_PAL_TAG_14, - EVENT_OBJ_PAL_TAG_14, - EVENT_OBJ_PAL_TAG_14, + OBJ_EVENT_PAL_TAG_14, + OBJ_EVENT_PAL_TAG_14, + OBJ_EVENT_PAL_TAG_14, + OBJ_EVENT_PAL_TAG_14, }; const u16 gMachokeMoverReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_15, - EVENT_OBJ_PAL_TAG_15, - EVENT_OBJ_PAL_TAG_15, - EVENT_OBJ_PAL_TAG_15, + OBJ_EVENT_PAL_TAG_15, + OBJ_EVENT_PAL_TAG_15, + OBJ_EVENT_PAL_TAG_15, + OBJ_EVENT_PAL_TAG_15, }; const u16 gMovingBoxReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_19, - EVENT_OBJ_PAL_TAG_19, - EVENT_OBJ_PAL_TAG_19, - EVENT_OBJ_PAL_TAG_19, + OBJ_EVENT_PAL_TAG_19, + OBJ_EVENT_PAL_TAG_19, + OBJ_EVENT_PAL_TAG_19, + OBJ_EVENT_PAL_TAG_19, }; const u16 gCableCarReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_20, - EVENT_OBJ_PAL_TAG_20, - EVENT_OBJ_PAL_TAG_20, - EVENT_OBJ_PAL_TAG_20, + OBJ_EVENT_PAL_TAG_20, + OBJ_EVENT_PAL_TAG_20, + OBJ_EVENT_PAL_TAG_20, + OBJ_EVENT_PAL_TAG_20, }; const u16 gSSTidalReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_21, - EVENT_OBJ_PAL_TAG_21, - EVENT_OBJ_PAL_TAG_21, - EVENT_OBJ_PAL_TAG_21, + OBJ_EVENT_PAL_TAG_21, + OBJ_EVENT_PAL_TAG_21, + OBJ_EVENT_PAL_TAG_21, + OBJ_EVENT_PAL_TAG_21, }; const u16 gSubmarineShadowReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_26, - EVENT_OBJ_PAL_TAG_26, - EVENT_OBJ_PAL_TAG_26, - EVENT_OBJ_PAL_TAG_26, + OBJ_EVENT_PAL_TAG_26, + OBJ_EVENT_PAL_TAG_26, + OBJ_EVENT_PAL_TAG_26, + OBJ_EVENT_PAL_TAG_26, }; const u16 gKyogre2ReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_23, - EVENT_OBJ_PAL_TAG_23, - EVENT_OBJ_PAL_TAG_23, - EVENT_OBJ_PAL_TAG_23, + OBJ_EVENT_PAL_TAG_23, + OBJ_EVENT_PAL_TAG_23, + OBJ_EVENT_PAL_TAG_23, + OBJ_EVENT_PAL_TAG_23, }; const u16 gGroudon2ReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_25, - EVENT_OBJ_PAL_TAG_25, - EVENT_OBJ_PAL_TAG_25, - EVENT_OBJ_PAL_TAG_25, + OBJ_EVENT_PAL_TAG_25, + OBJ_EVENT_PAL_TAG_25, + OBJ_EVENT_PAL_TAG_25, + OBJ_EVENT_PAL_TAG_25, }; const u16 gInvisibleKecleonReflectionPaletteTags[] = { - EVENT_OBJ_PAL_TAG_6, - EVENT_OBJ_PAL_TAG_6, - EVENT_OBJ_PAL_TAG_6, - EVENT_OBJ_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_6, }; const struct ReflectionPaletteSet gSpecialObjectReflectionPaletteSets[] = { - {EVENT_OBJ_PAL_TAG_8, gPlayerReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_17, gPlayerReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_12, gQuintyPlumpReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_14, gTruckReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_15, gMachokeMoverReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_19, gMovingBoxReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_20, gCableCarReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_21, gSSTidalReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_22, gKyogre2ReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_24, gGroudon2ReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_2, gInvisibleKecleonReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_26, gSubmarineShadowReflectionPaletteTags}, - {EVENT_OBJ_PAL_TAG_NONE, NULL}, + {OBJ_EVENT_PAL_TAG_8, gPlayerReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_17, gPlayerReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_12, gQuintyPlumpReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_14, gTruckReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_15, gMachokeMoverReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_19, gMovingBoxReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_20, gCableCarReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_21, gSSTidalReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_22, gKyogre2ReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_24, gGroudon2ReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_2, gInvisibleKecleonReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_26, gSubmarineShadowReflectionPaletteTags}, + {OBJ_EVENT_PAL_TAG_NONE, NULL}, }; const u16 gObjectPaletteTags0[] = { - EVENT_OBJ_PAL_TAG_8, - EVENT_OBJ_PAL_TAG_9, - EVENT_OBJ_PAL_TAG_0, - EVENT_OBJ_PAL_TAG_1, - EVENT_OBJ_PAL_TAG_2, - EVENT_OBJ_PAL_TAG_3, - EVENT_OBJ_PAL_TAG_4, - EVENT_OBJ_PAL_TAG_5, - EVENT_OBJ_PAL_TAG_6, - EVENT_OBJ_PAL_TAG_7, + OBJ_EVENT_PAL_TAG_8, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_0, + OBJ_EVENT_PAL_TAG_1, + OBJ_EVENT_PAL_TAG_2, + OBJ_EVENT_PAL_TAG_3, + OBJ_EVENT_PAL_TAG_4, + OBJ_EVENT_PAL_TAG_5, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_7, }; const u16 gObjectPaletteTags1[] = { - EVENT_OBJ_PAL_TAG_8, - EVENT_OBJ_PAL_TAG_9, - EVENT_OBJ_PAL_TAG_0, - EVENT_OBJ_PAL_TAG_1, - EVENT_OBJ_PAL_TAG_2, - EVENT_OBJ_PAL_TAG_3, - EVENT_OBJ_PAL_TAG_4, - EVENT_OBJ_PAL_TAG_5, - EVENT_OBJ_PAL_TAG_6, - EVENT_OBJ_PAL_TAG_7, + OBJ_EVENT_PAL_TAG_8, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_0, + OBJ_EVENT_PAL_TAG_1, + OBJ_EVENT_PAL_TAG_2, + OBJ_EVENT_PAL_TAG_3, + OBJ_EVENT_PAL_TAG_4, + OBJ_EVENT_PAL_TAG_5, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_7, }; const u16 gObjectPaletteTags2[] = { - EVENT_OBJ_PAL_TAG_8, - EVENT_OBJ_PAL_TAG_9, - EVENT_OBJ_PAL_TAG_0, - EVENT_OBJ_PAL_TAG_1, - EVENT_OBJ_PAL_TAG_2, - EVENT_OBJ_PAL_TAG_3, - EVENT_OBJ_PAL_TAG_4, - EVENT_OBJ_PAL_TAG_5, - EVENT_OBJ_PAL_TAG_6, - EVENT_OBJ_PAL_TAG_7, + OBJ_EVENT_PAL_TAG_8, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_0, + OBJ_EVENT_PAL_TAG_1, + OBJ_EVENT_PAL_TAG_2, + OBJ_EVENT_PAL_TAG_3, + OBJ_EVENT_PAL_TAG_4, + OBJ_EVENT_PAL_TAG_5, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_7, }; const u16 gObjectPaletteTags3[] = { - EVENT_OBJ_PAL_TAG_8, - EVENT_OBJ_PAL_TAG_9, - EVENT_OBJ_PAL_TAG_0, - EVENT_OBJ_PAL_TAG_1, - EVENT_OBJ_PAL_TAG_2, - EVENT_OBJ_PAL_TAG_3, - EVENT_OBJ_PAL_TAG_4, - EVENT_OBJ_PAL_TAG_5, - EVENT_OBJ_PAL_TAG_6, - EVENT_OBJ_PAL_TAG_7, + OBJ_EVENT_PAL_TAG_8, + OBJ_EVENT_PAL_TAG_9, + OBJ_EVENT_PAL_TAG_0, + OBJ_EVENT_PAL_TAG_1, + OBJ_EVENT_PAL_TAG_2, + OBJ_EVENT_PAL_TAG_3, + OBJ_EVENT_PAL_TAG_4, + OBJ_EVENT_PAL_TAG_5, + OBJ_EVENT_PAL_TAG_6, + OBJ_EVENT_PAL_TAG_7, }; const u16 *const gObjectPaletteTagSets[] = { @@ -591,14 +591,14 @@ const u16 *const gObjectPaletteTagSets[] = { gObjectPaletteTags3, }; -#include "data/field_event_obj/berry_tree_graphics_tables.h" -#include "data/field_event_obj/field_effect_objects.h" +#include "data/object_event/berry_tree_graphics_tables.h" +#include "data/object_event/field_effect_objects.h" const s16 gMovementDelaysMedium[] = {32, 64, 96, 128}; const s16 gMovementDelaysLong[] = {32, 64, 128, 192}; const s16 gMovementDelaysShort[] = {32, 48, 64, 80}; -#include "data/field_event_obj/movement_type_func_tables.h" +#include "data/object_event/movement_type_func_tables.h" const u8 gFaceDirectionAnimNums[] = { 0, // DIR_NONE @@ -1019,7 +1019,7 @@ const u8 gUnknown_08375767[][4] = { {3, 4, 2, 1} }; -#include "data/field_event_obj/movement_action_func_tables.h" +#include "data/object_event/movement_action_func_tables.h" // There is code supporing multiple sets of player reflection palettes, but // the data for each is identical. Perhaps non-water/ice reflections were planned. @@ -1027,45 +1027,45 @@ static u8 sCurrentReflectionType; static u16 sCurrentSpecialObjectPaletteTag; -extern struct LinkPlayerEventObject gLinkPlayerEventObjects[]; +extern struct LinkPlayerObjectEvent gLinkPlayerObjectEvents[]; extern u8 gReservedSpritePaletteCount; extern struct Camera gCamera; -extern struct EventObject gEventObjects[16]; +extern struct ObjectEvent gObjectEvents[16]; #if DEBUG u8 gUnknown_Debug_03004BC0; #endif -static void ClearEventObject(struct EventObject *eventObject) +static void ClearObjectEvent(struct ObjectEvent *objectEvent) { - memset(eventObject, 0, sizeof(struct EventObject)); - eventObject->localId = 0xFF; - eventObject->mapNum = 0xFF; - eventObject->mapGroup = 0xFF; - eventObject->movementActionId = 0xFF; + memset(objectEvent, 0, sizeof(struct ObjectEvent)); + objectEvent->localId = 0xFF; + objectEvent->mapNum = 0xFF; + objectEvent->mapGroup = 0xFF; + objectEvent->movementActionId = 0xFF; } -static void ClearAllEventObjects(void) +static void ClearAllObjectEvents(void) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) - ClearEventObject(&gEventObjects[i]); + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) + ClearObjectEvent(&gObjectEvents[i]); #if DEBUG gUnknown_Debug_03004BC0 = 0; #endif } -void ResetEventObjects(void) +void ResetObjectEvents(void) { - ClearLinkPlayerEventObjects(); - ClearAllEventObjects(); + ClearLinkPlayerObjectEvents(); + ClearAllObjectEvents(); ClearPlayerAvatarInfo(); CreateReflectionEffectSprites(); } static void CreateReflectionEffectSprites(void) { - // The reflection effect when an event object is standing over water or ice + // The reflection effect when an object event is standing over water or ice // is driven by these two invisible sprites' callback functions. The callback // continuously updates OAM rot/scale matrices using affine animations that scale // the sprite up and down horizontally. The second one is needed to handle the inverted @@ -1083,218 +1083,218 @@ static void CreateReflectionEffectSprites(void) gSprites[spriteId].invisible = TRUE; } -u8 GetFirstInactiveEventObjectId(void) +u8 GetFirstInactiveObjectEventId(void) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (!gEventObjects[i].active) + if (!gObjectEvents[i].active) break; } return i; } -u8 GetEventObjectIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +u8 GetObjectEventIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { if (localId < 0xFF) - return GetEventObjectIdByLocalIdAndMapInternal(localId, mapNum, mapGroup); + return GetObjectEventIdByLocalIdAndMapInternal(localId, mapNum, mapGroup); else - return GetEventObjectIdByLocalId(localId); + return GetObjectEventIdByLocalId(localId); } -bool8 TryGetEventObjectIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 *eventObjectId) +bool8 TryGetObjectEventIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 *objectEventId) { - *eventObjectId = GetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup); - if (*eventObjectId == EVENT_OBJECTS_COUNT) + *objectEventId = GetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup); + if (*objectEventId == OBJECT_EVENTS_COUNT) return TRUE; else return FALSE; } -u8 GetEventObjectIdByXY(s16 x, s16 y) +u8 GetObjectEventIdByXY(s16 x, s16 y) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (gEventObjects[i].active && gEventObjects[i].currentCoords.x == x && gEventObjects[i].currentCoords.y == y) + if (gObjectEvents[i].active && gObjectEvents[i].currentCoords.x == x && gObjectEvents[i].currentCoords.y == y) break; } return i; } -static u8 GetEventObjectIdByLocalIdAndMapInternal(u8 localId, u8 mapNum, u8 mapGroup) +static u8 GetObjectEventIdByLocalIdAndMapInternal(u8 localId, u8 mapNum, u8 mapGroup) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (gEventObjects[i].active && gEventObjects[i].localId == localId && gEventObjects[i].mapNum == mapNum && gEventObjects[i].mapGroup == mapGroup) + if (gObjectEvents[i].active && gObjectEvents[i].localId == localId && gObjectEvents[i].mapNum == mapNum && gObjectEvents[i].mapGroup == mapGroup) return i; } - return EVENT_OBJECTS_COUNT; + return OBJECT_EVENTS_COUNT; } -static u8 GetEventObjectIdByLocalId(u8 localId) +static u8 GetObjectEventIdByLocalId(u8 localId) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (gEventObjects[i].active && gEventObjects[i].localId == localId) + if (gObjectEvents[i].active && gObjectEvents[i].localId == localId) return i; } - return EVENT_OBJECTS_COUNT; + return OBJECT_EVENTS_COUNT; } -static u8 InitEventObjectStateFromTemplate(struct EventObjectTemplate *template, u8 mapNum, u8 mapGroup) +static u8 InitObjectEventStateFromTemplate(struct ObjectEventTemplate *template, u8 mapNum, u8 mapGroup) { - struct EventObject *eventObject; - u8 eventObjectId; + struct ObjectEvent *objectEvent; + u8 objectEventId; s16 initialX; s16 initialY; - if (GetAvailableEventObjectId(template->localId, mapNum, mapGroup, &eventObjectId) != 0) - return EVENT_OBJECTS_COUNT; + if (GetAvailableObjectEventId(template->localId, mapNum, mapGroup, &objectEventId) != 0) + return OBJECT_EVENTS_COUNT; - eventObject = &gEventObjects[eventObjectId]; - ClearEventObject(eventObject); + objectEvent = &gObjectEvents[objectEventId]; + ClearObjectEvent(objectEvent); initialX = template->x + 7; initialY = template->y + 7; - eventObject->active = TRUE; - eventObject->triggerGroundEffectsOnMove = TRUE; - eventObject->graphicsId = template->graphicsId; - eventObject->movementType = template->movementType; - eventObject->localId = template->localId; - eventObject->mapNum = mapNum; + objectEvent->active = TRUE; + objectEvent->triggerGroundEffectsOnMove = TRUE; + objectEvent->graphicsId = template->graphicsId; + objectEvent->movementType = template->movementType; + objectEvent->localId = template->localId; + objectEvent->mapNum = mapNum; asm("":::"r6"); - eventObject->mapGroup = mapGroup; - eventObject->initialCoords.x = initialX; - eventObject->initialCoords.y = initialY; - eventObject->currentCoords.x = initialX; - eventObject->currentCoords.y = initialY; - eventObject->previousCoords.x = initialX; - eventObject->previousCoords.y = initialY; - eventObject->currentElevation = template->elevation; - eventObject->previousElevation = template->elevation; - 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]; - SetEventObjectDirection(eventObject, eventObject->previousMovementDirection); + objectEvent->mapGroup = mapGroup; + objectEvent->initialCoords.x = initialX; + objectEvent->initialCoords.y = initialY; + objectEvent->currentCoords.x = initialX; + objectEvent->currentCoords.y = initialY; + objectEvent->previousCoords.x = initialX; + objectEvent->previousCoords.y = initialY; + objectEvent->currentElevation = template->elevation; + objectEvent->previousElevation = template->elevation; + objectEvent->range.as_nybbles.x = template->movementRangeX; + objectEvent->range.as_nybbles.y = template->movementRangeY; + objectEvent->trainerType = template->trainerType; + objectEvent->trainerRange_berryTreeId = template->trainerRange_berryTreeId; + objectEvent->previousMovementDirection = gInitialMovementTypeFacingDirections[template->movementType]; + SetObjectEventDirection(objectEvent, objectEvent->previousMovementDirection); asm("":::"r5","r6"); - SetEventObjectDynamicGraphicsId(eventObject); + SetObjectEventDynamicGraphicsId(objectEvent); - if (gRangedMovementTypes[eventObject->movementType]) + if (gRangedMovementTypes[objectEvent->movementType]) { // Ensure a ranged movement type has at least 1 tile of room to move. - if (eventObject->range.as_nybbles.x == 0) - eventObject->range.as_nybbles.x++; - if (eventObject->range.as_nybbles.y == 0) - eventObject->range.as_nybbles.y++; + if (objectEvent->range.as_nybbles.x == 0) + objectEvent->range.as_nybbles.x++; + if (objectEvent->range.as_nybbles.y == 0) + objectEvent->range.as_nybbles.y++; } #if DEBUG gUnknown_Debug_03004BC0++; #endif - return eventObjectId; + return objectEventId; } -u8 TryInitLocalEventObject(u8 localId) +u8 TryInitLocalObjectEvent(u8 localId) { u8 i; - u8 eventObjectCount; + u8 objectEventCount; if (gMapHeader.events == NULL) - return EVENT_OBJECTS_COUNT; + return OBJECT_EVENTS_COUNT; - eventObjectCount = gMapHeader.events->eventObjectCount; - for (i = 0; i < eventObjectCount; i++) + objectEventCount = gMapHeader.events->objectEventCount; + for (i = 0; i < objectEventCount; i++) { - struct EventObjectTemplate *template = &gSaveBlock1.eventObjectTemplates[i]; + struct ObjectEventTemplate *template = &gSaveBlock1.objectEventTemplates[i]; if (template->localId == localId && !FlagGet(template->flagId)) - return InitEventObjectStateFromTemplate(template, gSaveBlock1.location.mapNum, gSaveBlock1.location.mapGroup); + return InitObjectEventStateFromTemplate(template, gSaveBlock1.location.mapNum, gSaveBlock1.location.mapGroup); } - return EVENT_OBJECTS_COUNT; + return OBJECT_EVENTS_COUNT; } -static bool8 GetAvailableEventObjectId(u16 localId, u8 mapNum, u8 mapGroup, u8 *eventObjectId) +static bool8 GetAvailableObjectEventId(u16 localId, u8 mapNum, u8 mapGroup, u8 *objectEventId) { u8 i = 0; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (!gEventObjects[i].active) + if (!gObjectEvents[i].active) break; - if (gEventObjects[i].localId == localId && gEventObjects[i].mapNum == mapNum && gEventObjects[i].mapGroup == mapGroup) + if (gObjectEvents[i].localId == localId && gObjectEvents[i].mapNum == mapNum && gObjectEvents[i].mapGroup == mapGroup) return TRUE; } - if (i >= EVENT_OBJECTS_COUNT) + if (i >= OBJECT_EVENTS_COUNT) return TRUE; - *eventObjectId = i; - for (; i < EVENT_OBJECTS_COUNT; i++) + *objectEventId = i; + for (; i < OBJECT_EVENTS_COUNT; i++) { - if (gEventObjects[i].active && gEventObjects[i].localId == localId && gEventObjects[i].mapNum == mapNum && gEventObjects[i].mapGroup == mapGroup) + if (gObjectEvents[i].active && gObjectEvents[i].localId == localId && gObjectEvents[i].mapNum == mapNum && gObjectEvents[i].mapGroup == mapGroup) return TRUE; } return FALSE; } -static void RemoveEventObject(struct EventObject *eventObject) +static void RemoveObjectEvent(struct ObjectEvent *objectEvent) { - eventObject->active = FALSE; - RemoveEventObjectInternal(eventObject); + objectEvent->active = FALSE; + RemoveObjectEventInternal(objectEvent); #if DEBUG gUnknown_Debug_03004BC0--; #endif } -void RemoveEventObjectByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +void RemoveObjectEventByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { - u8 eventObjectId; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + u8 objectEventId; + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { - FlagSet(GetEventObjectFlagIdByEventObjectId(eventObjectId)); - RemoveEventObject(&gEventObjects[eventObjectId]); + FlagSet(GetObjectEventFlagIdByObjectEventId(objectEventId)); + RemoveObjectEvent(&gObjectEvents[objectEventId]); } } -static void RemoveEventObjectInternal(struct EventObject *eventObject) +static void RemoveObjectEventInternal(struct ObjectEvent *objectEvent) { struct SpriteFrameImage image; - image.size = GetEventObjectGraphicsInfo(eventObject->graphicsId)->size; - gSprites[eventObject->spriteId].images = ℑ - DestroySprite(&gSprites[eventObject->spriteId]); + image.size = GetObjectEventGraphicsInfo(objectEvent->graphicsId)->size; + gSprites[objectEvent->spriteId].images = ℑ + DestroySprite(&gSprites[objectEvent->spriteId]); } -void RemoveAllEventObjectsExceptPlayer(void) +void RemoveAllObjectEventsExceptPlayer(void) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (i != gPlayerAvatar.eventObjectId) - RemoveEventObject(&gEventObjects[i]); + if (i != gPlayerAvatar.objectEventId) + RemoveObjectEvent(&gObjectEvents[i]); } } -static u8 TrySetupEventObjectSprite(struct EventObjectTemplate *eventObjectTemplate, struct SpriteTemplate *spriteTemplate, u8 mapNum, u8 mapGroup, s16 cameraDeltaX, s16 cameraDeltaY) +static u8 TrySetupObjectEventSprite(struct ObjectEventTemplate *objectEventTemplate, struct SpriteTemplate *spriteTemplate, u8 mapNum, u8 mapGroup, s16 cameraDeltaX, s16 cameraDeltaY) { u8 spriteId; - u8 eventObjectId; + u8 objectEventId; struct Sprite *sprite; - struct EventObject *eventObject; - const struct EventObjectGraphicsInfo *graphicsInfo; + struct ObjectEvent *objectEvent; + const struct ObjectEventGraphicsInfo *graphicsInfo; - eventObjectId = InitEventObjectStateFromTemplate(eventObjectTemplate, mapNum, mapGroup); - if (eventObjectId == EVENT_OBJECTS_COUNT) - return EVENT_OBJECTS_COUNT; + objectEventId = InitObjectEventStateFromTemplate(objectEventTemplate, mapNum, mapGroup); + if (objectEventId == OBJECT_EVENTS_COUNT) + return OBJECT_EVENTS_COUNT; - eventObject = &gEventObjects[eventObjectId]; - graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + objectEvent = &gObjectEvents[objectEventId]; + graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId); if (graphicsInfo->paletteSlot == 0) { LoadPlayerObjectReflectionPalette(graphicsInfo->paletteTag, graphicsInfo->paletteSlot); @@ -1303,9 +1303,9 @@ static u8 TrySetupEventObjectSprite(struct EventObjectTemplate *eventObjectTempl { LoadSpecialObjectReflectionPalette(graphicsInfo->paletteTag, graphicsInfo->paletteSlot); } - if (eventObject->movementType == MOVEMENT_TYPE_INVISIBLE) + if (objectEvent->movementType == MOVEMENT_TYPE_INVISIBLE) { - eventObject->invisible = TRUE; + objectEvent->invisible = TRUE; } *(u16 *)&spriteTemplate->paletteTag = 0xFFFF; spriteId = CreateSprite(spriteTemplate, 0, 0, 0); @@ -1314,101 +1314,101 @@ static u8 TrySetupEventObjectSprite(struct EventObjectTemplate *eventObjectTempl #if DEBUG gUnknown_Debug_03004BC0--; #endif - gEventObjects[eventObjectId].active = FALSE; - return EVENT_OBJECTS_COUNT; + gObjectEvents[objectEventId].active = FALSE; + return OBJECT_EVENTS_COUNT; } sprite = &gSprites[spriteId]; - sub_8060388(cameraDeltaX + eventObject->currentCoords.x, cameraDeltaY + eventObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); + sub_8060388(cameraDeltaX + objectEvent->currentCoords.x, cameraDeltaY + objectEvent->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->oam.paletteNum = graphicsInfo->paletteSlot; sprite->coordOffsetEnabled = TRUE; - sprite->data[0] = eventObjectId; - eventObject->spriteId = spriteId; - eventObject->inanimate = graphicsInfo->inanimate; - if (!eventObject->inanimate) + sprite->data[0] = objectEventId; + objectEvent->spriteId = spriteId; + objectEvent->inanimate = graphicsInfo->inanimate; + if (!objectEvent->inanimate) { - StartSpriteAnim(sprite, GetFaceDirectionAnimNum(eventObject->facingDirection)); + StartSpriteAnim(sprite, GetFaceDirectionAnimNum(objectEvent->facingDirection)); } - SetObjectSubpriorityByZCoord(eventObject->previousElevation, sprite, 1); - UpdateEventObjectVisibility(eventObject, sprite); - return eventObjectId; + SetObjectSubpriorityByZCoord(objectEvent->previousElevation, sprite, 1); + UpdateObjectEventVisibility(objectEvent, sprite); + return objectEventId; } -static u8 TrySpawnEventObject(struct EventObjectTemplate *eventObjectTemplate, u8 mapNum, u8 mapGroup, s16 cameraDeltaX, s16 cameraDeltaY) +static u8 TrySpawnObjectEvent(struct ObjectEventTemplate *objectEventTemplate, u8 mapNum, u8 mapGroup, s16 cameraDeltaX, s16 cameraDeltaY) { - u8 eventObjectId; + u8 objectEventId; struct SpriteTemplate spriteTemplate; struct SpriteFrameImage spriteFrameImage; - const struct EventObjectGraphicsInfo *graphicsInfo; + const struct ObjectEventGraphicsInfo *graphicsInfo; const struct SubspriteTable *subspriteTables = NULL; - graphicsInfo = GetEventObjectGraphicsInfo(eventObjectTemplate->graphicsId); - MakeObjectTemplateFromEventObjectTemplate(eventObjectTemplate, &spriteTemplate, &subspriteTables); + graphicsInfo = GetObjectEventGraphicsInfo(objectEventTemplate->graphicsId); + MakeObjectTemplateFromObjectEventTemplate(objectEventTemplate, &spriteTemplate, &subspriteTables); spriteFrameImage.size = graphicsInfo->size; spriteTemplate.images = &spriteFrameImage; - eventObjectId = TrySetupEventObjectSprite(eventObjectTemplate, &spriteTemplate, mapNum, mapGroup, cameraDeltaX, cameraDeltaY); - if (eventObjectId == EVENT_OBJECTS_COUNT) + objectEventId = TrySetupObjectEventSprite(objectEventTemplate, &spriteTemplate, mapNum, mapGroup, cameraDeltaX, cameraDeltaY); + if (objectEventId == OBJECT_EVENTS_COUNT) { - return EVENT_OBJECTS_COUNT; + return OBJECT_EVENTS_COUNT; } - gSprites[gEventObjects[eventObjectId].spriteId].images = graphicsInfo->images; + gSprites[gObjectEvents[objectEventId].spriteId].images = graphicsInfo->images; if (subspriteTables != NULL) { - SetSubspriteTables(&gSprites[gEventObjects[eventObjectId].spriteId], subspriteTables); + SetSubspriteTables(&gSprites[gObjectEvents[objectEventId].spriteId], subspriteTables); } - return eventObjectId; + return objectEventId; } -u8 SpawnSpecialEventObject(struct EventObjectTemplate *eventObjectTemplate) +u8 SpawnSpecialObjectEvent(struct ObjectEventTemplate *objectEventTemplate) { s16 x; s16 y; - GetEventObjectMovingCameraOffset(&x, &y); - return TrySpawnEventObject(eventObjectTemplate, gSaveBlock1.location.mapNum, gSaveBlock1.location.mapGroup, x, y); + GetObjectEventMovingCameraOffset(&x, &y); + return TrySpawnObjectEvent(objectEventTemplate, gSaveBlock1.location.mapNum, gSaveBlock1.location.mapGroup, x, y); } -u8 SpawnSpecialEventObjectParametrized(u8 graphicsId, u8 movementType, u8 localId, s16 x, s16 y, u8 elevation) +u8 SpawnSpecialObjectEventParametrized(u8 graphicsId, u8 movementType, u8 localId, s16 x, s16 y, u8 elevation) { - struct EventObjectTemplate eventObjectTemplate; + struct ObjectEventTemplate objectEventTemplate; x -= 7; y -= 7; - eventObjectTemplate.localId = localId; - eventObjectTemplate.graphicsId = graphicsId; - eventObjectTemplate.unk2 = 0; - eventObjectTemplate.x = x; - eventObjectTemplate.y = y; - eventObjectTemplate.elevation = elevation; - eventObjectTemplate.movementType = movementType; - eventObjectTemplate.movementRangeX = 0; - eventObjectTemplate.movementRangeY = 0; - eventObjectTemplate.trainerType = 0; - eventObjectTemplate.trainerRange_berryTreeId = 0; - return SpawnSpecialEventObject(&eventObjectTemplate); + objectEventTemplate.localId = localId; + objectEventTemplate.graphicsId = graphicsId; + objectEventTemplate.unk2 = 0; + objectEventTemplate.x = x; + objectEventTemplate.y = y; + objectEventTemplate.elevation = elevation; + objectEventTemplate.movementType = movementType; + objectEventTemplate.movementRangeX = 0; + objectEventTemplate.movementRangeY = 0; + objectEventTemplate.trainerType = 0; + objectEventTemplate.trainerRange_berryTreeId = 0; + return SpawnSpecialObjectEvent(&objectEventTemplate); } u8 show_sprite(u8 localId, u8 mapNum, u8 mapGroup) { - struct EventObjectTemplate *eventObjectTemplate; + struct ObjectEventTemplate *objectEventTemplate; s16 x; s16 y; - eventObjectTemplate = GetEventObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup); - if (eventObjectTemplate == NULL) + objectEventTemplate = GetObjectEventTemplateByLocalIdAndMap(localId, mapNum, mapGroup); + if (objectEventTemplate == NULL) { - return EVENT_OBJECTS_COUNT; + return OBJECT_EVENTS_COUNT; } - GetEventObjectMovingCameraOffset(&x, &y); - return TrySpawnEventObject(eventObjectTemplate, mapNum, mapGroup, x, y); + GetObjectEventMovingCameraOffset(&x, &y); + return TrySpawnObjectEvent(objectEventTemplate, mapNum, mapGroup, x, y); } -void MakeObjectTemplateFromEventObjectGraphicsInfo(u16 graphicsId, void (*callback)(struct Sprite *), struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) +void MakeObjectTemplateFromObjectEventGraphicsInfo(u16 graphicsId, void (*callback)(struct Sprite *), struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) { - const struct EventObjectGraphicsInfo *graphicsInfo = GetEventObjectGraphicsInfo(graphicsId); + const struct ObjectEventGraphicsInfo *graphicsInfo = GetObjectEventGraphicsInfo(graphicsId); spriteTemplate->tileTag = graphicsInfo->tileTag; spriteTemplate->paletteTag = graphicsInfo->paletteTag; @@ -1420,23 +1420,23 @@ void MakeObjectTemplateFromEventObjectGraphicsInfo(u16 graphicsId, void (*callba *subspriteTables = graphicsInfo->subspriteTables; } -static void MakeObjectTemplateFromEventObjectGraphicsInfoWithCallbackIndex(u16 graphicsId, u16 movementType, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) +static void MakeObjectTemplateFromObjectEventGraphicsInfoWithCallbackIndex(u16 graphicsId, u16 movementType, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) { - MakeObjectTemplateFromEventObjectGraphicsInfo(graphicsId, sMovementTypeCallbacks[movementType], spriteTemplate, subspriteTables); + MakeObjectTemplateFromObjectEventGraphicsInfo(graphicsId, sMovementTypeCallbacks[movementType], spriteTemplate, subspriteTables); } -static void MakeObjectTemplateFromEventObjectTemplate(struct EventObjectTemplate *eventObjTemplate, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) +static void MakeObjectTemplateFromObjectEventTemplate(struct ObjectEventTemplate *objEventTemplate, struct SpriteTemplate *spriteTemplate, const struct SubspriteTable **subspriteTables) { - MakeObjectTemplateFromEventObjectGraphicsInfoWithCallbackIndex(eventObjTemplate->graphicsId, eventObjTemplate->movementType, spriteTemplate, subspriteTables); + MakeObjectTemplateFromObjectEventGraphicsInfoWithCallbackIndex(objEventTemplate->graphicsId, objEventTemplate->movementType, spriteTemplate, subspriteTables); } -u8 AddPseudoEventObject(u16 graphicsId, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority) +u8 AddPseudoObjectEvent(u16 graphicsId, void (*callback)(struct Sprite *), s16 x, s16 y, u8 subpriority) { struct SpriteTemplate spriteTemplate; const struct SubspriteTable *subspriteTables; u8 spriteId; - MakeObjectTemplateFromEventObjectGraphicsInfo(graphicsId, callback, &spriteTemplate, &subspriteTables); + MakeObjectTemplateFromObjectEventGraphicsInfo(graphicsId, callback, &spriteTemplate, &subspriteTables); if (spriteTemplate.paletteTag != 0xFFFF) { sub_805BDF8(spriteTemplate.paletteTag); @@ -1455,10 +1455,10 @@ u8 sub_805B410(u8 graphicsId, u8 b, s16 x, s16 y, u8 elevation, u8 direction) u8 spriteId; struct SpriteTemplate spriteTemplate; const struct SubspriteTable *subspriteTables; - const struct EventObjectGraphicsInfo *graphicsInfo; + const struct ObjectEventGraphicsInfo *graphicsInfo; - graphicsInfo = GetEventObjectGraphicsInfo(graphicsId); - MakeObjectTemplateFromEventObjectGraphicsInfo(graphicsId, UpdateEventObjectSpriteSubpriorityAndVisibility, &spriteTemplate, &subspriteTables); + graphicsInfo = GetObjectEventGraphicsInfo(graphicsId); + MakeObjectTemplateFromObjectEventGraphicsInfo(graphicsId, UpdateObjectEventSpriteSubpriorityAndVisibility, &spriteTemplate, &subspriteTables); *(u16 *)&spriteTemplate.paletteTag = 0xFFFF; x += 7; y += 7; @@ -1491,7 +1491,7 @@ u8 sub_805B410(u8 graphicsId, u8 b, s16 x, s16 y, u8 elevation, u8 direction) return spriteId; } -void TrySpawnEventObjects(s16 cameraDeltaX, s16 cameraDeltaY) +void TrySpawnObjectEvents(s16 cameraDeltaX, s16 cameraDeltaY) { u8 i; @@ -1501,57 +1501,57 @@ void TrySpawnEventObjects(s16 cameraDeltaX, s16 cameraDeltaY) s16 right = gSaveBlock1.pos.x + 17; s16 top = gSaveBlock1.pos.y; s16 bottom = gSaveBlock1.pos.y + 16; - u8 objectCount = gMapHeader.events->eventObjectCount; + u8 objectCount = gMapHeader.events->objectEventCount; for (i = 0; i < objectCount; i++) { - struct EventObjectTemplate *template = &gSaveBlock1.eventObjectTemplates[i]; + struct ObjectEventTemplate *template = &gSaveBlock1.objectEventTemplates[i]; s16 npcX = template->x + 7; s16 npcY = template->y + 7; if (top <= npcY && bottom >= npcY && left <= npcX && right >= npcX && !FlagGet(template->flagId)) - TrySpawnEventObject(template, gSaveBlock1.location.mapNum, gSaveBlock1.location.mapGroup, cameraDeltaX, cameraDeltaY); + TrySpawnObjectEvent(template, gSaveBlock1.location.mapNum, gSaveBlock1.location.mapGroup, cameraDeltaX, cameraDeltaY); } } } -void RemoveEventObjectsOutsideView(void) +void RemoveObjectEventsOutsideView(void) { u8 i, j; bool8 isActiveLinkPlayer; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { for (j = 0, isActiveLinkPlayer = FALSE; j < 4; j++) { - if (gLinkPlayerEventObjects[j].active && i == gLinkPlayerEventObjects[j].eventObjId) + if (gLinkPlayerObjectEvents[j].active && i == gLinkPlayerObjectEvents[j].objEventId) isActiveLinkPlayer = TRUE; } if (!isActiveLinkPlayer) { - struct EventObject *eventObject = &gEventObjects[i]; + struct ObjectEvent *objectEvent = &gObjectEvents[i]; - if (eventObject->active && !eventObject->isPlayer) - RemoveEventObjectIfOutsideView(eventObject); + if (objectEvent->active && !objectEvent->isPlayer) + RemoveObjectEventIfOutsideView(objectEvent); } } } -static void RemoveEventObjectIfOutsideView(struct EventObject *eventObject) +static void RemoveObjectEventIfOutsideView(struct ObjectEvent *objectEvent) { s16 left = gSaveBlock1.pos.x - 2; s16 right = gSaveBlock1.pos.x + 17; s16 top = gSaveBlock1.pos.y; s16 bottom = gSaveBlock1.pos.y + 16; - if (eventObject->currentCoords.x >= left && eventObject->currentCoords.x <= right - && eventObject->currentCoords.y >= top && eventObject->currentCoords.y <= bottom) + if (objectEvent->currentCoords.x >= left && objectEvent->currentCoords.x <= right + && objectEvent->currentCoords.y >= top && objectEvent->currentCoords.y <= bottom) return; - if (eventObject->initialCoords.x >= left && eventObject->initialCoords.x <= right - && eventObject->initialCoords.y >= top && eventObject->initialCoords.y <= bottom) + if (objectEvent->initialCoords.x >= left && objectEvent->initialCoords.x <= right + && objectEvent->initialCoords.y >= top && objectEvent->initialCoords.y <= bottom) return; - RemoveEventObject(eventObject); + RemoveObjectEvent(objectEvent); } void sub_805B75C(u8, s16, s16); @@ -1564,9 +1564,9 @@ void sub_805B710(u16 a, u16 b) gUnknown_Debug_03004BC0 = 0; #endif ClearPlayerAvatarInfo(); - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (gEventObjects[i].active) + if (gObjectEvents[i].active) { sub_805B75C(i, a, b); #if DEBUG @@ -1577,30 +1577,30 @@ void sub_805B710(u16 a, u16 b) CreateReflectionEffectSprites(); } -void sub_805B75C(u8 eventObjectId, s16 x, s16 y) +void sub_805B75C(u8 objectEventId, s16 x, s16 y) { u8 spriteId; struct Sprite *sprite; - struct EventObject *eventObject; + struct ObjectEvent *objectEvent; struct SpriteTemplate spriteTemplate; struct SpriteFrameImage spriteFrameImage; const struct SubspriteTable *subspriteTables; - const struct EventObjectGraphicsInfo *graphicsInfo; + const struct ObjectEventGraphicsInfo *graphicsInfo; #define i spriteId for (i = 0; i < 4; i++) { - if (gLinkPlayerEventObjects[i].active && eventObjectId == gLinkPlayerEventObjects[i].eventObjId) + if (gLinkPlayerObjectEvents[i].active && objectEventId == gLinkPlayerObjectEvents[i].objEventId) return; } #undef i - eventObject = &gEventObjects[eventObjectId]; + objectEvent = &gObjectEvents[objectEventId]; asm("":::"r5"); subspriteTables = NULL; - graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId); spriteFrameImage.size = graphicsInfo->size; - MakeObjectTemplateFromEventObjectGraphicsInfoWithCallbackIndex(eventObject->graphicsId, eventObject->movementType, &spriteTemplate, &subspriteTables); + MakeObjectTemplateFromObjectEventGraphicsInfoWithCallbackIndex(objectEvent->graphicsId, objectEvent->movementType, &spriteTemplate, &subspriteTables); spriteTemplate.images = &spriteFrameImage; *(u16 *)&spriteTemplate.paletteTag = 0xFFFF; if (graphicsInfo->paletteSlot == 0) @@ -1616,16 +1616,16 @@ void sub_805B75C(u8 eventObjectId, s16 x, s16 y) if (spriteId != MAX_SPRITES) { sprite = &gSprites[spriteId]; - sub_8060388(x + eventObject->currentCoords.x, y + eventObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); + sub_8060388(x + objectEvent->currentCoords.x, y + objectEvent->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 (eventObject->movementType == MOVEMENT_TYPE_PLAYER) + if (objectEvent->movementType == MOVEMENT_TYPE_PLAYER) { - SetPlayerAvatarEventObjectIdAndObjectId(eventObjectId, spriteId); - eventObject->warpArrowSpriteId = CreateWarpArrowSprite(); + SetPlayerAvatarObjectEventIdAndObjectId(objectEventId, spriteId); + objectEvent->warpArrowSpriteId = CreateWarpArrowSprite(); } if (subspriteTables != NULL) { @@ -1633,45 +1633,45 @@ void sub_805B75C(u8 eventObjectId, s16 x, s16 y) } sprite->oam.paletteNum = graphicsInfo->paletteSlot; sprite->coordOffsetEnabled = TRUE; - sprite->data[0] = eventObjectId; - eventObject->spriteId = spriteId; - if (!eventObject->inanimate && eventObject->movementType != MOVEMENT_TYPE_PLAYER) + sprite->data[0] = objectEventId; + objectEvent->spriteId = spriteId; + if (!objectEvent->inanimate && objectEvent->movementType != MOVEMENT_TYPE_PLAYER) { - StartSpriteAnim(sprite, GetFaceDirectionAnimNum(eventObject->facingDirection)); + StartSpriteAnim(sprite, GetFaceDirectionAnimNum(objectEvent->facingDirection)); } - sub_805B914(eventObject); - SetObjectSubpriorityByZCoord(eventObject->previousElevation, sprite, 1); + sub_805B914(objectEvent); + SetObjectSubpriorityByZCoord(objectEvent->previousElevation, sprite, 1); } } -static void sub_805B914(struct EventObject *eventObject) +static void sub_805B914(struct ObjectEvent *objectEvent) { - eventObject->singleMovementActive = FALSE; - eventObject->triggerGroundEffectsOnMove = TRUE; - eventObject->hasShadow = FALSE; - eventObject->hasReflection = FALSE; - eventObject->inShortGrass = FALSE; - eventObject->inShallowFlowingWater = FALSE; - eventObject->inSandPile = FALSE; - eventObject->inHotSprings = FALSE; - EventObjectClearHeldMovement(eventObject); + objectEvent->singleMovementActive = FALSE; + objectEvent->triggerGroundEffectsOnMove = TRUE; + objectEvent->hasShadow = FALSE; + objectEvent->hasReflection = FALSE; + objectEvent->inShortGrass = FALSE; + objectEvent->inShallowFlowingWater = FALSE; + objectEvent->inSandPile = FALSE; + objectEvent->inHotSprings = FALSE; + ObjectEventClearHeldMovement(objectEvent); } -static void SetPlayerAvatarEventObjectIdAndObjectId(u8 eventObjectId, u8 spriteId) +static void SetPlayerAvatarObjectEventIdAndObjectId(u8 objectEventId, u8 spriteId) { - gPlayerAvatar.eventObjectId = eventObjectId; + gPlayerAvatar.objectEventId = objectEventId; gPlayerAvatar.spriteId = spriteId; - gPlayerAvatar.gender = GetPlayerAvatarGenderByGraphicsId(gEventObjects[eventObjectId].graphicsId); - SetPlayerAvatarExtraStateTransition(gEventObjects[eventObjectId].graphicsId, 0x20); + gPlayerAvatar.gender = GetPlayerAvatarGenderByGraphicsId(gObjectEvents[objectEventId].graphicsId); + SetPlayerAvatarExtraStateTransition(gObjectEvents[objectEventId].graphicsId, 0x20); } -void EventObjectSetGraphicsId(struct EventObject *eventObject, u8 graphicsId) +void ObjectEventSetGraphicsId(struct ObjectEvent *objectEvent, u8 graphicsId) { - const struct EventObjectGraphicsInfo *graphicsInfo; + const struct ObjectEventGraphicsInfo *graphicsInfo; struct Sprite *sprite; - graphicsInfo = GetEventObjectGraphicsInfo(graphicsId); - sprite = &gSprites[eventObject->spriteId]; + graphicsInfo = GetObjectEventGraphicsInfo(graphicsId); + sprite = &gSprites[objectEvent->spriteId]; if (graphicsInfo->paletteSlot == 0) { PatchObjectPalette(graphicsInfo->paletteTag, graphicsInfo->paletteSlot); @@ -1686,166 +1686,166 @@ void EventObjectSetGraphicsId(struct EventObject *eventObject, u8 graphicsId) sprite->anims = graphicsInfo->anims; sprite->subspriteTables = graphicsInfo->subspriteTables; sprite->oam.paletteNum = graphicsInfo->paletteSlot; - eventObject->inanimate = graphicsInfo->inanimate; - eventObject->graphicsId = graphicsId; - sub_80603CC(eventObject->currentCoords.x, eventObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); + objectEvent->inanimate = graphicsInfo->inanimate; + objectEvent->graphicsId = graphicsId; + sub_80603CC(objectEvent->currentCoords.x, objectEvent->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 (eventObject->trackedByCamera) + if (objectEvent->trackedByCamera) { CameraObjectReset1(); } } -void EventObjectSetGraphicsIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 graphicsId) +void ObjectEventSetGraphicsIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 graphicsId) { - u8 eventObjectId; + u8 objectEventId; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { - EventObjectSetGraphicsId(&gEventObjects[eventObjectId], graphicsId); + ObjectEventSetGraphicsId(&gObjectEvents[objectEventId], graphicsId); } } -void EventObjectTurn(struct EventObject *eventObject, u8 direction) +void ObjectEventTurn(struct ObjectEvent *objectEvent, u8 direction) { - SetEventObjectDirection(eventObject, direction); - if (!eventObject->inanimate) + SetObjectEventDirection(objectEvent, direction); + if (!objectEvent->inanimate) { - StartSpriteAnim(&gSprites[eventObject->spriteId], GetFaceDirectionAnimNum(eventObject->facingDirection)); - SeekSpriteAnim(&gSprites[eventObject->spriteId], 0); + StartSpriteAnim(&gSprites[objectEvent->spriteId], GetFaceDirectionAnimNum(objectEvent->facingDirection)); + SeekSpriteAnim(&gSprites[objectEvent->spriteId], 0); } } -void EventObjectTurnByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 direction) +void ObjectEventTurnByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup, u8 direction) { - u8 eventObjectId; + u8 objectEventId; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { - EventObjectTurn(&gEventObjects[eventObjectId], direction); + ObjectEventTurn(&gObjectEvents[objectEventId], direction); } } void PlayerObjectTurn(struct PlayerAvatar *playerAvatar, u8 direction) { - EventObjectTurn(&gEventObjects[playerAvatar->eventObjectId], direction); + ObjectEventTurn(&gObjectEvents[playerAvatar->objectEventId], direction); } -static void get_berry_tree_graphics(struct EventObject *eventObject, struct Sprite *sprite) +static void get_berry_tree_graphics(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 berryStage; u8 berryId; - eventObject->invisible = TRUE; + objectEvent->invisible = TRUE; sprite->invisible = TRUE; - berryStage = GetStageByBerryTreeId(eventObject->trainerRange_berryTreeId); + berryStage = GetStageByBerryTreeId(objectEvent->trainerRange_berryTreeId); if (berryStage != 0) { - eventObject->invisible = FALSE; + objectEvent->invisible = FALSE; sprite->invisible = FALSE; - berryId = GetBerryTypeByBerryTreeId(eventObject->trainerRange_berryTreeId) - 1; + berryId = GetBerryTypeByBerryTreeId(objectEvent->trainerRange_berryTreeId) - 1; berryStage--; if (berryId > 0x2B) { berryId = 0; } - EventObjectSetGraphicsId(eventObject, gBerryTreeGraphicsIdTablePointers[berryId][berryStage]); + ObjectEventSetGraphicsId(objectEvent, gBerryTreeGraphicsIdTablePointers[berryId][berryStage]); sprite->images = gBerryTreePicTablePointers[berryId]; sprite->oam.paletteNum = gBerryTreePaletteSlotTablePointers[berryId][berryStage]; StartSpriteAnim(sprite, berryStage); } } -const struct EventObjectGraphicsInfo *GetEventObjectGraphicsInfo(u8 graphicsId) +const struct ObjectEventGraphicsInfo *GetObjectEventGraphicsInfo(u8 graphicsId) { if (graphicsId > SPRITE_VAR) { - graphicsId = VarGetEventObjectGraphicsId(graphicsId + 16); + graphicsId = VarGetObjectEventGraphicsId(graphicsId + 16); } if (graphicsId > NUM_OBJECT_GRAPHICS_INFO) { - graphicsId = EVENT_OBJ_GFX_LITTLE_BOY_1; + graphicsId = OBJ_EVENT_GFX_LITTLE_BOY_1; } - return gEventObjectGraphicsInfoPointers[graphicsId]; + return gObjectEventGraphicsInfoPointers[graphicsId]; } -static void SetEventObjectDynamicGraphicsId(struct EventObject *eventObject) +static void SetObjectEventDynamicGraphicsId(struct ObjectEvent *objectEvent) { - if (eventObject->graphicsId > SPRITE_VAR) + if (objectEvent->graphicsId > SPRITE_VAR) { - eventObject->graphicsId = VarGetEventObjectGraphicsId(eventObject->graphicsId + 16); + objectEvent->graphicsId = VarGetObjectEventGraphicsId(objectEvent->graphicsId + 16); } } void npc_by_local_id_and_map_set_field_1_bit_x20(u8 localId, u8 mapNum, u8 mapGroup, u8 state) { - u8 eventObjectId; + u8 objectEventId; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { - gEventObjects[eventObjectId].invisible = state; + gObjectEvents[objectEventId].invisible = state; } } -void EventObjectGetLocalIdAndMap(struct EventObject *eventObject, void *localId, void *mapNum, void *mapGroup) +void ObjectEventGetLocalIdAndMap(struct ObjectEvent *objectEvent, void *localId, void *mapNum, void *mapGroup) { - *(u8 *)localId = eventObject->localId; - *(u8 *)mapNum = eventObject->mapNum; - *(u8 *)mapGroup = eventObject->mapGroup; + *(u8 *)localId = objectEvent->localId; + *(u8 *)mapNum = objectEvent->mapNum; + *(u8 *)mapGroup = objectEvent->mapGroup; } void sub_805BCC0(s16 x, s16 y) { - u8 eventObjectId; - struct EventObject *eventObject; + u8 objectEventId; + struct ObjectEvent *objectEvent; - eventObjectId = GetEventObjectIdByXY(x, y); - if (eventObjectId != EVENT_OBJECTS_COUNT) + objectEventId = GetObjectEventIdByXY(x, y); + if (objectEventId != OBJECT_EVENTS_COUNT) { - eventObject = &gEventObjects[eventObjectId]; - eventObject->triggerGroundEffectsOnMove = TRUE; + objectEvent = &gObjectEvents[objectEventId]; + objectEvent->triggerGroundEffectsOnMove = TRUE; } } void sub_805BCF0(u8 localId, u8 mapNum, u8 mapGroup, u8 subpriority) { - u8 eventObjectId; - struct EventObject *eventObject; + u8 objectEventId; + struct ObjectEvent *objectEvent; struct Sprite *sprite; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { - eventObject = &gEventObjects[eventObjectId]; - sprite = &gSprites[eventObject->spriteId]; - eventObject->fixedPriority = TRUE; + objectEvent = &gObjectEvents[objectEventId]; + sprite = &gSprites[objectEvent->spriteId]; + objectEvent->fixedPriority = TRUE; sprite->subpriority = subpriority; } } void sub_805BD48(u8 localId, u8 mapNum, u8 mapGroup) { - u8 eventObjectId; - struct EventObject *eventObject; + u8 objectEventId; + struct ObjectEvent *objectEvent; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { - eventObject = &gEventObjects[eventObjectId]; - eventObject->fixedPriority = FALSE; - eventObject->triggerGroundEffectsOnMove = TRUE; + objectEvent = &gObjectEvents[objectEventId]; + objectEvent->fixedPriority = FALSE; + objectEvent->triggerGroundEffectsOnMove = TRUE; } } void sub_805BD90(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y) { - u8 eventObjectId; + u8 objectEventId; struct Sprite *sprite; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { - sprite = &gSprites[gEventObjects[eventObjectId].spriteId]; + sprite = &gSprites[gObjectEvents[objectEventId].spriteId]; sprite->pos2.x = x; sprite->pos2.y = y; } @@ -1859,11 +1859,11 @@ void FreeAndReserveObjectSpritePalettes(void) void sub_805BDF8(u16 paletteTag) { - u16 paletteSlot = FindEventObjectPaletteIndexByTag(paletteTag); + u16 paletteSlot = FindObjectEventPaletteIndexByTag(paletteTag); - if (paletteSlot != EVENT_OBJ_PAL_TAG_NONE) //always happens. FindEventObjectPaletteIndexByTag returns u8 + if (paletteSlot != OBJ_EVENT_PAL_TAG_NONE) //always happens. FindObjectEventPaletteIndexByTag returns u8 { - sub_805BE58(&sEventObjectSpritePalettes[paletteSlot]); + sub_805BE58(&sObjectEventSpritePalettes[paletteSlot]); } } @@ -1871,7 +1871,7 @@ void unref_sub_805BE24(u16 *paletteTags) { u8 i; - for (i = 0; paletteTags[i] != EVENT_OBJ_PAL_TAG_NONE; i++) + for (i = 0; paletteTags[i] != OBJ_EVENT_PAL_TAG_NONE; i++) sub_805BDF8(paletteTags[i]); } @@ -1886,9 +1886,9 @@ static u8 sub_805BE58(const struct SpritePalette *palette) void PatchObjectPalette(u16 paletteTag, u8 paletteSlot) { - u8 paletteIndex = FindEventObjectPaletteIndexByTag(paletteTag); + u8 paletteIndex = FindObjectEventPaletteIndexByTag(paletteTag); - LoadPalette(sEventObjectSpritePalettes[paletteIndex].data, 16 * paletteSlot + 0x100, 0x20); + LoadPalette(sObjectEventSpritePalettes[paletteIndex].data, 16 * paletteSlot + 0x100, 0x20); } static void PatchObjectPalettes(const u16 *paletteTags, u8 minSlot, u8 maxSlot) @@ -1901,13 +1901,13 @@ static void PatchObjectPalettes(const u16 *paletteTags, u8 minSlot, u8 maxSlot) } } -static u8 FindEventObjectPaletteIndexByTag(u16 tag) +static u8 FindObjectEventPaletteIndexByTag(u16 tag) { u8 i; - for (i = 0; sEventObjectSpritePalettes[i].tag != EVENT_OBJ_PAL_TAG_NONE; i++) + for (i = 0; sObjectEventSpritePalettes[i].tag != OBJ_EVENT_PAL_TAG_NONE; i++) { - if (sEventObjectSpritePalettes[i].tag == tag) + if (sObjectEventSpritePalettes[i].tag == tag) { return i; } @@ -1920,7 +1920,7 @@ void LoadPlayerObjectReflectionPalette(u16 paletteTag, u8 paletteIndex) u8 i; PatchObjectPalette(paletteTag, paletteIndex); - for (i = 0; gPlayerReflectionPaletteSets[i].mainPaletteTag != EVENT_OBJ_PAL_TAG_NONE; i++) + for (i = 0; gPlayerReflectionPaletteSets[i].mainPaletteTag != OBJ_EVENT_PAL_TAG_NONE; i++) { if (gPlayerReflectionPaletteSets[i].mainPaletteTag == paletteTag) { @@ -1936,7 +1936,7 @@ void LoadSpecialObjectReflectionPalette(u16 paletteTag, u8 paletteIndex) sCurrentSpecialObjectPaletteTag = paletteTag; PatchObjectPalette(paletteTag, paletteIndex); - for (i = 0; gSpecialObjectReflectionPaletteSets[i].mainPaletteTag != EVENT_OBJ_PAL_TAG_NONE; i++) + for (i = 0; gSpecialObjectReflectionPaletteSets[i].mainPaletteTag != OBJ_EVENT_PAL_TAG_NONE; i++) { if (gSpecialObjectReflectionPaletteSets[i].mainPaletteTag == paletteTag) { @@ -1946,64 +1946,64 @@ void LoadSpecialObjectReflectionPalette(u16 paletteTag, u8 paletteIndex) } } -void unref_sub_805C014(struct EventObject *eventObject, s16 x, s16 y) +void unref_sub_805C014(struct ObjectEvent *objectEvent, s16 x, s16 y) { - eventObject->previousCoords.x = eventObject->currentCoords.x; - eventObject->previousCoords.y = eventObject->currentCoords.y; - eventObject->currentCoords.x += x; - eventObject->currentCoords.y += y; + objectEvent->previousCoords.x = objectEvent->currentCoords.x; + objectEvent->previousCoords.y = objectEvent->currentCoords.y; + objectEvent->currentCoords.x += x; + objectEvent->currentCoords.y += y; } -void ShiftEventObjectCoords(struct EventObject *eventObject, s16 x, s16 y) +void ShiftObjectEventCoords(struct ObjectEvent *objectEvent, s16 x, s16 y) { - eventObject->previousCoords.x = eventObject->currentCoords.x; - eventObject->previousCoords.y = eventObject->currentCoords.y; - eventObject->currentCoords.x = x; - eventObject->currentCoords.y = y; + objectEvent->previousCoords.x = objectEvent->currentCoords.x; + objectEvent->previousCoords.y = objectEvent->currentCoords.y; + objectEvent->currentCoords.x = x; + objectEvent->currentCoords.y = y; } -static void SetEventObjectCoords(struct EventObject *eventObject, s16 x, s16 y) +static void SetObjectEventCoords(struct ObjectEvent *objectEvent, s16 x, s16 y) { - eventObject->previousCoords.x = x; - eventObject->previousCoords.y = y; - eventObject->currentCoords.x = x; - eventObject->currentCoords.y = y; + objectEvent->previousCoords.x = x; + objectEvent->previousCoords.y = y; + objectEvent->currentCoords.x = x; + objectEvent->currentCoords.y = y; } -void sub_805C058(struct EventObject *eventObject, s16 x, s16 y) +void sub_805C058(struct ObjectEvent *objectEvent, s16 x, s16 y) { - struct Sprite *sprite = &gSprites[eventObject->spriteId]; - const struct EventObjectGraphicsInfo *graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + struct Sprite *sprite = &gSprites[objectEvent->spriteId]; + const struct ObjectEventGraphicsInfo *graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId); - SetEventObjectCoords(eventObject, x, y); - sub_80603CC(eventObject->currentCoords.x, eventObject->currentCoords.y, &sprite->pos1.x, &sprite->pos1.y); + SetObjectEventCoords(objectEvent, x, y); + sub_80603CC(objectEvent->currentCoords.x, objectEvent->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_805B914(eventObject); - if (eventObject->trackedByCamera) + sub_805B914(objectEvent); + if (objectEvent->trackedByCamera) CameraObjectReset1(); } void sub_805C0F8(u8 localId, u8 mapNum, u8 mapGroup, s16 x, s16 y) { - u8 eventObjectId; + u8 objectEventId; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { x += 7; y += 7; - sub_805C058(&gEventObjects[eventObjectId], x, y); + sub_805C058(&gObjectEvents[objectEventId], x, y); } } -void ShiftStillEventObjectCoords(struct EventObject *eventObject) +void ShiftStillObjectEventCoords(struct ObjectEvent *objectEvent) { - ShiftEventObjectCoords(eventObject, eventObject->currentCoords.x, eventObject->currentCoords.y); + ShiftObjectEventCoords(objectEvent, objectEvent->currentCoords.x, objectEvent->currentCoords.y); } -void UpdateEventObjectCoordsForCameraUpdate(void) +void UpdateObjectEventCoordsForCameraUpdate(void) { u8 i; s16 deltaX; @@ -2013,52 +2013,52 @@ void UpdateEventObjectCoordsForCameraUpdate(void) { deltaX = gCamera.x; deltaY = gCamera.y; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (gEventObjects[i].active) + if (gObjectEvents[i].active) { - gEventObjects[i].initialCoords.x -= deltaX; - gEventObjects[i].initialCoords.y -= deltaY; - gEventObjects[i].currentCoords.x -= deltaX; - gEventObjects[i].currentCoords.y -= deltaY; - gEventObjects[i].previousCoords.x -= deltaX; - gEventObjects[i].previousCoords.y -= deltaY; + gObjectEvents[i].initialCoords.x -= deltaX; + gObjectEvents[i].initialCoords.y -= deltaY; + gObjectEvents[i].currentCoords.x -= deltaX; + gObjectEvents[i].currentCoords.y -= deltaY; + gObjectEvents[i].previousCoords.x -= deltaX; + gObjectEvents[i].previousCoords.y -= deltaY; } } } } -u8 GetEventObjectIdByXYZ(u16 x, u16 y, u8 z) +u8 GetObjectEventIdByXYZ(u16 x, u16 y, u8 z) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - if (gEventObjects[i].active) + if (gObjectEvents[i].active) { - if (gEventObjects[i].currentCoords.x == x && gEventObjects[i].currentCoords.y == y && EventObjectDoesZCoordMatch(&gEventObjects[i], z)) + if (gObjectEvents[i].currentCoords.x == x && gObjectEvents[i].currentCoords.y == y && ObjectEventDoesZCoordMatch(&gObjectEvents[i], z)) { return i; } } } - return EVENT_OBJECTS_COUNT; + return OBJECT_EVENTS_COUNT; } -static bool8 EventObjectDoesZCoordMatch(struct EventObject *eventObject, u8 z) +static bool8 ObjectEventDoesZCoordMatch(struct ObjectEvent *objectEvent, u8 z) { - if (eventObject->currentElevation != 0 && z != 0 && eventObject->currentElevation != z) + if (objectEvent->currentElevation != 0 && z != 0 && objectEvent->currentElevation != z) { return FALSE; } return TRUE; } -void UpdateEventObjectsForCameraUpdate(s16 cameraDeltaX, s16 cameraDeltaY) +void UpdateObjectEventsForCameraUpdate(s16 cameraDeltaX, s16 cameraDeltaY) { - UpdateEventObjectCoordsForCameraUpdate(); - TrySpawnEventObjects(cameraDeltaX, cameraDeltaY); - RemoveEventObjectsOutsideView(); + UpdateObjectEventCoordsForCameraUpdate(); + TrySpawnObjectEvents(cameraDeltaX, cameraDeltaY); + RemoveObjectEventsOutsideView(); } u8 AddCameraObject(u8 trackedSpriteId) @@ -2194,80 +2194,80 @@ u8 CreateCopySpriteAt(struct Sprite *src, s16 x, s16 y, u8 subpriority) return MAX_SPRITES; } -void SetEventObjectDirection(struct EventObject *eventObject, u8 direction) +void SetObjectEventDirection(struct ObjectEvent *objectEvent, u8 direction) { - eventObject->previousMovementDirection = eventObject->facingDirection; - if (!eventObject->facingDirectionLocked) + objectEvent->previousMovementDirection = objectEvent->facingDirection; + if (!objectEvent->facingDirectionLocked) { s8 _direction = direction; //needed for the asm to match - eventObject->facingDirection = _direction; + objectEvent->facingDirection = _direction; } - eventObject->movementDirection = direction; + objectEvent->movementDirection = direction; } -static const u8 *GetEventObjectScriptPointerByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +static const u8 *GetObjectEventScriptPointerByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { - return GetEventObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->script; + return GetObjectEventTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->script; } -const u8 *GetEventObjectScriptPointerByEventObjectId(u8 eventObjectId) +const u8 *GetObjectEventScriptPointerByObjectEventId(u8 objectEventId) { - return GetEventObjectScriptPointerByLocalIdAndMap(gEventObjects[eventObjectId].localId, gEventObjects[eventObjectId].mapNum, gEventObjects[eventObjectId].mapGroup); + return GetObjectEventScriptPointerByLocalIdAndMap(gObjectEvents[objectEventId].localId, gObjectEvents[objectEventId].mapNum, gObjectEvents[objectEventId].mapGroup); } -static u16 GetEventObjectFlagIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +static u16 GetObjectEventFlagIdByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { - return GetEventObjectTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->flagId; + return GetObjectEventTemplateByLocalIdAndMap(localId, mapNum, mapGroup)->flagId; } -static u16 GetEventObjectFlagIdByEventObjectId(u8 eventObjectId) +static u16 GetObjectEventFlagIdByObjectEventId(u8 objectEventId) { - return GetEventObjectFlagIdByLocalIdAndMap(gEventObjects[eventObjectId].localId, gEventObjects[eventObjectId].mapNum, gEventObjects[eventObjectId].mapGroup); + return GetObjectEventFlagIdByLocalIdAndMap(gObjectEvents[objectEventId].localId, gObjectEvents[objectEventId].mapNum, gObjectEvents[objectEventId].mapGroup); } u8 unref_sub_805C5D0(u8 localId, u8 mapNum, u8 mapGroup) { - u8 eventObjectId; + u8 objectEventId; - if (TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) return 0xFF; else - return gEventObjects[eventObjectId].trainerType; + return gObjectEvents[objectEventId].trainerType; } -u8 unref_sub_805C60C(u8 eventObjectId) +u8 unref_sub_805C60C(u8 objectEventId) { - return gEventObjects[eventObjectId].trainerType; + return gObjectEvents[objectEventId].trainerType; } u8 unref_sub_805C624(u8 localId, u8 mapNum, u8 mapGroup) { - u8 eventObjectId; + u8 objectEventId; - if (TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + if (TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) return 0xFF; else - return gEventObjects[eventObjectId].trainerRange_berryTreeId; + return gObjectEvents[objectEventId].trainerRange_berryTreeId; } -u8 EventObjectGetBerryTreeId(u8 eventObjectId) +u8 ObjectEventGetBerryTreeId(u8 objectEventId) { - return gEventObjects[eventObjectId].trainerRange_berryTreeId; + return gObjectEvents[objectEventId].trainerRange_berryTreeId; } -struct EventObjectTemplate *GetEventObjectTemplateByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) +struct ObjectEventTemplate *GetObjectEventTemplateByLocalIdAndMap(u8 localId, u8 mapNum, u8 mapGroup) { if (gSaveBlock1.location.mapNum == mapNum && gSaveBlock1.location.mapGroup == mapGroup) - return FindEventObjectTemplateByLocalId(localId, gSaveBlock1.eventObjectTemplates, gMapHeader.events->eventObjectCount); + return FindObjectEventTemplateByLocalId(localId, gSaveBlock1.objectEventTemplates, gMapHeader.events->objectEventCount); else { struct MapHeader *mapHeader = Overworld_GetMapHeaderByGroupAndId(mapGroup, mapNum); - return FindEventObjectTemplateByLocalId(localId, mapHeader->events->eventObjects, mapHeader->events->eventObjectCount); + return FindObjectEventTemplateByLocalId(localId, mapHeader->events->objectEvents, mapHeader->events->objectEventCount); } } -static struct EventObjectTemplate *FindEventObjectTemplateByLocalId(u8 localId, struct EventObjectTemplate *templates, u8 count) +static struct ObjectEventTemplate *FindObjectEventTemplateByLocalId(u8 localId, struct ObjectEventTemplate *templates, u8 count) { u8 i; @@ -2279,53 +2279,53 @@ static struct EventObjectTemplate *FindEventObjectTemplateByLocalId(u8 localId, return NULL; } -static struct EventObjectTemplate *GetBaseTemplateForEventObject(struct EventObject *eventObject) +static struct ObjectEventTemplate *GetBaseTemplateForObjectEvent(struct ObjectEvent *objectEvent) { s32 i; - if (eventObject->mapNum != gSaveBlock1.location.mapNum - || eventObject->mapGroup != gSaveBlock1.location.mapGroup) + if (objectEvent->mapNum != gSaveBlock1.location.mapNum + || objectEvent->mapGroup != gSaveBlock1.location.mapGroup) return NULL; for (i = 0; i < 64; i++) { - if (eventObject->localId == gSaveBlock1.eventObjectTemplates[i].localId) - return &gSaveBlock1.eventObjectTemplates[i]; + if (objectEvent->localId == gSaveBlock1.objectEventTemplates[i].localId) + return &gSaveBlock1.objectEventTemplates[i]; } return NULL; } -void OverrideTemplateCoordsForEventObject(struct EventObject *eventObject) +void OverrideTemplateCoordsForObjectEvent(struct ObjectEvent *objectEvent) { - struct EventObjectTemplate *template = GetBaseTemplateForEventObject(eventObject); + struct ObjectEventTemplate *template = GetBaseTemplateForObjectEvent(objectEvent); if (template != NULL) { - template->x = eventObject->currentCoords.x - 7; - template->y = eventObject->currentCoords.y - 7; + template->x = objectEvent->currentCoords.x - 7; + template->y = objectEvent->currentCoords.y - 7; } } -void OverrideMovementTypeForEventObject(struct EventObject *eventObject, u8 movementType) +void OverrideMovementTypeForObjectEvent(struct ObjectEvent *objectEvent, u8 movementType) { - struct EventObjectTemplate *template = GetBaseTemplateForEventObject(eventObject); + struct ObjectEventTemplate *template = GetBaseTemplateForObjectEvent(objectEvent); if (template != NULL) template->movementType = movementType; } -void TryOverrideTemplateCoordsForEventObject(u8 localId, u8 mapNum, u8 mapGroup) +void TryOverrideTemplateCoordsForObjectEvent(u8 localId, u8 mapNum, u8 mapGroup) { - u8 eventObjectId; + u8 objectEventId; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) - OverrideTemplateCoordsForEventObject(&gEventObjects[eventObjectId]); + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) + OverrideTemplateCoordsForObjectEvent(&gObjectEvents[objectEventId]); } -void InitEventObjectPalettes(u8 reflectionType) +void InitObjectEventPalettes(u8 reflectionType) { FreeAndReserveObjectSpritePalettes(); - sCurrentSpecialObjectPaletteTag = EVENT_OBJ_PAL_TAG_NONE; + sCurrentSpecialObjectPaletteTag = OBJ_EVENT_PAL_TAG_NONE; sCurrentReflectionType = reflectionType; PatchObjectPalettes(gObjectPaletteTagSets[sCurrentReflectionType], 0, 10); } @@ -2339,7 +2339,7 @@ u16 GetObjectPaletteTag(u8 paletteIndex) return gObjectPaletteTagSets[sCurrentReflectionType][paletteIndex]; // Palette slots 10 and 11 belong to the special object. - for (i = 0; gSpecialObjectReflectionPaletteSets[i].mainPaletteTag != EVENT_OBJ_PAL_TAG_NONE; i++) + for (i = 0; gSpecialObjectReflectionPaletteSets[i].mainPaletteTag != OBJ_EVENT_PAL_TAG_NONE; i++) { if (gSpecialObjectReflectionPaletteSets[i].mainPaletteTag == sCurrentSpecialObjectPaletteTag) { @@ -2347,29 +2347,29 @@ u16 GetObjectPaletteTag(u8 paletteIndex) } } - return EVENT_OBJ_PAL_TAG_NONE; + return OBJ_EVENT_PAL_TAG_NONE; } movement_type_empty_callback(MovementType_None); movement_type_def(MovementType_WanderAround, gMovementTypeFuncs_WanderAround); -bool8 MovementType_WanderAround_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderAround_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_WanderAround_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderAround_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_WanderAround_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderAround_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite) == 0) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite) == 0) { return FALSE; } @@ -2378,7 +2378,7 @@ bool8 MovementType_WanderAround_Step2(struct EventObject *eventObject, struct Sp return TRUE; } -bool8 MovementType_WanderAround_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderAround_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite)) { @@ -2388,40 +2388,40 @@ bool8 MovementType_WanderAround_Step3(struct EventObject *eventObject, struct Sp return FALSE; } -bool8 MovementType_WanderAround_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderAround_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; memcpy(directions, gStandardDirections, 4); direction = directions[Random() & 3]; - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 5; - if (GetCollisionInDirection(eventObject, direction) != 0) + if (GetCollisionInDirection(objectEvent, direction) != 0) { sprite->data[1] = 1; } return TRUE; } -bool8 MovementType_WanderAround_Step5(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderAround_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetWalkNormalMovementAction(eventObject->movementDirection)); - eventObject->singleMovementActive = 1; + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkNormalMovementAction(objectEvent->movementDirection)); + objectEvent->singleMovementActive = 1; sprite->data[1] = 6; return TRUE; } -bool8 MovementType_WanderAround_Step6(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderAround_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite) != 0) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite) != 0) { - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 1; } return FALSE; } -bool8 EventObjectIsTrainerAndCloseToPlayer(struct EventObject *eventObject) +bool8 ObjectEventIsTrainerAndCloseToPlayer(struct ObjectEvent *objectEvent) { s16 x; s16 y; @@ -2435,17 +2435,17 @@ bool8 EventObjectIsTrainerAndCloseToPlayer(struct EventObject *eventObject) { return FALSE; } - if (eventObject->trainerType != 1 && eventObject->trainerType != 3) + if (objectEvent->trainerType != 1 && objectEvent->trainerType != 3) { return FALSE; } PlayerGetDestCoords(&x, &y); - 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; + objx = objectEvent->currentCoords.x; + objy = objectEvent->currentCoords.y; + minx = objx - objectEvent->trainerRange_berryTreeId; + miny = objy - objectEvent->trainerRange_berryTreeId; + maxx = objx + objectEvent->trainerRange_berryTreeId; + maxy = objy + objectEvent->trainerRange_berryTreeId; if (minx > x || maxx < x || miny > y || maxy < y) { return FALSE; @@ -2632,17 +2632,17 @@ u8 GetLimitedVectorDirection_SouthWestEast(s16 x, s16 y, s16 xAbs, s16 yAbs) return direction; } -u8 TryGetTrainerEncounterDirection(struct EventObject *eventObject, u8 directionFuncIndex) +u8 TryGetTrainerEncounterDirection(struct ObjectEvent *objectEvent, u8 directionFuncIndex) { s16 x, y; s16 xAbs, yAbs; - if (!EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (!ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { return 0; } PlayerGetDestCoords(&x, &y); - x -= eventObject->currentCoords.x; - y -= eventObject->currentCoords.y; + x -= objectEvent->currentCoords.x; + y -= objectEvent->currentCoords.y; xAbs = x; yAbs = y; if (xAbs < 0) @@ -2655,34 +2655,34 @@ u8 TryGetTrainerEncounterDirection(struct EventObject *eventObject, u8 direction movement_type_def(MovementType_LookAround, gMovementTypeFuncs_LookAround); -bool8 MovementType_LookAround_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_LookAround_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_LookAround_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_LookAround_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_LookAround_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_LookAround_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysMedium[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_LookAround_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_LookAround_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -2690,39 +2690,39 @@ bool8 MovementType_LookAround_Step3(struct EventObject *eventObject, struct Spri return FALSE; } -bool8 MovementType_LookAround_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_LookAround_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; memcpy(directions, gStandardDirections, sizeof directions); - direction = TryGetTrainerEncounterDirection(eventObject, 0); + direction = TryGetTrainerEncounterDirection(objectEvent, 0); if (direction == DIR_NONE) direction = directions[Random() & 3]; - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_WanderUpAndDown, gMovementTypeFuncs_WanderUpAndDown); -bool8 MovementType_WanderUpAndDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderUpAndDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_WanderUpAndDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderUpAndDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_WanderUpAndDown_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderUpAndDown_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite) == 0) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite) == 0) { return FALSE; } @@ -2731,7 +2731,7 @@ bool8 MovementType_WanderUpAndDown_Step2(struct EventObject *eventObject, struct return TRUE; } -bool8 MovementType_WanderUpAndDown_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderUpAndDown_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite)) { @@ -2741,34 +2741,34 @@ bool8 MovementType_WanderUpAndDown_Step3(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementType_WanderUpAndDown_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderUpAndDown_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; memcpy(directions, gUpAndDownDirections, sizeof directions); direction = directions[Random() & 1]; - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 5; - if (GetCollisionInDirection(eventObject, direction) != 0) + if (GetCollisionInDirection(objectEvent, direction) != 0) { sprite->data[1] = 1; } return TRUE; } -bool8 MovementType_WanderUpAndDown_Step5(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderUpAndDown_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetWalkNormalMovementAction(eventObject->movementDirection)); - eventObject->singleMovementActive = 1; + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkNormalMovementAction(objectEvent->movementDirection)); + objectEvent->singleMovementActive = 1; sprite->data[1] = 6; return TRUE; } -bool8 MovementType_WanderUpAndDown_Step6(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderUpAndDown_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite) != 0) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite) != 0) { - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 1; } return FALSE; @@ -2776,23 +2776,23 @@ bool8 MovementType_WanderUpAndDown_Step6(struct EventObject *eventObject, struct movement_type_def(MovementType_WanderLeftAndRight, gMovementTypeFuncs_WanderLeftAndRight); -bool8 MovementType_WanderLeftAndRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite) == 0) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite) == 0) { return FALSE; } @@ -2801,7 +2801,7 @@ bool8 MovementType_WanderLeftAndRight_Step2(struct EventObject *eventObject, str return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (WaitForMovementDelay(sprite)) { @@ -2811,34 +2811,34 @@ bool8 MovementType_WanderLeftAndRight_Step3(struct EventObject *eventObject, str return FALSE; } -bool8 MovementType_WanderLeftAndRight_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; memcpy(directions, gLeftAndRightDirections, sizeof directions); direction = directions[Random() & 1]; - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 5; - if (GetCollisionInDirection(eventObject, direction) != 0) + if (GetCollisionInDirection(objectEvent, direction) != 0) { sprite->data[1] = 1; } return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step5(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderLeftAndRight_Step5(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetWalkNormalMovementAction(eventObject->movementDirection)); - eventObject->singleMovementActive = 1; + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkNormalMovementAction(objectEvent->movementDirection)); + objectEvent->singleMovementActive = 1; sprite->data[1] = 6; return TRUE; } -bool8 MovementType_WanderLeftAndRight_Step6(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WanderLeftAndRight_Step6(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite) != 0) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite) != 0) { - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 1; } return FALSE; @@ -2846,17 +2846,17 @@ bool8 MovementType_WanderLeftAndRight_Step6(struct EventObject *eventObject, str movement_type_def(MovementType_FaceDirection, gMovementTypeFuncs_FaceDirection); -bool8 MovementType_FaceDirection_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ClearObjectEventMovement(objectEvent, sprite); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDirection_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDirection_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite) != 0) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite) != 0) { sprite->data[1] = 2; return TRUE; @@ -2864,43 +2864,43 @@ bool8 MovementType_FaceDirection_Step1(struct EventObject *eventObject, struct S return FALSE; } -bool8 MovementType_FaceDirection_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDirection_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; return FALSE; } void MovementType_BerryTreeGrowth(struct Sprite *sprite) { - struct EventObject *eventObject; + struct ObjectEvent *objectEvent; - eventObject = &gEventObjects[sprite->data[0]]; + objectEvent = &gObjectEvents[sprite->data[0]]; if (!(sprite->data[7] & 1)) { - get_berry_tree_graphics(eventObject, sprite); + get_berry_tree_graphics(objectEvent, sprite); sprite->data[7] |= 1; } - UpdateEventObjectCurrentMovement(eventObject, sprite, MovementType_BerryTreeGrowth_Callback); + UpdateObjectEventCurrentMovement(objectEvent, sprite, MovementType_BerryTreeGrowth_Callback); } -static u8 MovementType_BerryTreeGrowth_Callback(struct EventObject *eventObject, struct Sprite *sprite) +static u8 MovementType_BerryTreeGrowth_Callback(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - return gMovementTypeFuncs_BerryTreeGrowth[sprite->data[1]](eventObject, sprite); + return gMovementTypeFuncs_BerryTreeGrowth[sprite->data[1]](objectEvent, sprite); } -bool8 MovementType_BerryTreeGrowth_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_BerryTreeGrowth_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 berryTreeStage; - ClearEventObjectMovement(eventObject, sprite); - eventObject->invisible = TRUE; + ClearObjectEventMovement(objectEvent, sprite); + objectEvent->invisible = TRUE; sprite->invisible = TRUE; - berryTreeStage = GetStageByBerryTreeId(eventObject->trainerRange_berryTreeId); + berryTreeStage = GetStageByBerryTreeId(objectEvent->trainerRange_berryTreeId); if (!berryTreeStage) { if (!(sprite->data[7] & 4) && sprite->animNum == 4) { - gFieldEffectArguments[0] = eventObject->currentCoords.x; - gFieldEffectArguments[1] = eventObject->currentCoords.y; + gFieldEffectArguments[0] = objectEvent->currentCoords.x; + gFieldEffectArguments[1] = objectEvent->currentCoords.y; gFieldEffectArguments[2] = sprite->subpriority - 1; gFieldEffectArguments[3] = sprite->oam.priority; FieldEffectStart(FLDEFF_BERRY_TREE_GROWTH_SPARKLE); @@ -2908,7 +2908,7 @@ bool8 MovementType_BerryTreeGrowth_Step0(struct EventObject *eventObject, struct } return FALSE; } - eventObject->invisible = FALSE; + objectEvent->invisible = FALSE; sprite->invisible = FALSE; berryTreeStage--; if (sprite->animNum != berryTreeStage) @@ -2916,15 +2916,15 @@ bool8 MovementType_BerryTreeGrowth_Step0(struct EventObject *eventObject, struct sprite->data[1] = 2; return TRUE; } - get_berry_tree_graphics(eventObject, sprite); - EventObjectSetSingleMovement(eventObject, sprite, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION); + get_berry_tree_graphics(objectEvent, sprite); + ObjectEventSetSingleMovement(objectEvent, sprite, MOVEMENT_ACTION_START_ANIM_IN_DIRECTION); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_BerryTreeGrowth_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_BerryTreeGrowth_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { sprite->data[1] = 0; return TRUE; @@ -2932,28 +2932,28 @@ bool8 MovementType_BerryTreeGrowth_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementType_BerryTreeGrowth_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_BerryTreeGrowth_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->singleMovementActive = 1; + objectEvent->singleMovementActive = 1; sprite->data[1] = 3; sprite->data[2] = 0; sprite->data[7] |= 2; - gFieldEffectArguments[0] = eventObject->currentCoords.x; - gFieldEffectArguments[1] = eventObject->currentCoords.y; + gFieldEffectArguments[0] = objectEvent->currentCoords.x; + gFieldEffectArguments[1] = objectEvent->currentCoords.y; gFieldEffectArguments[2] = sprite->subpriority - 1; gFieldEffectArguments[3] = sprite->oam.priority; FieldEffectStart(FLDEFF_BERRY_TREE_GROWTH_SPARKLE); return TRUE; } -bool8 MovementType_BerryTreeGrowth_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_BerryTreeGrowth_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->data[2]++; - eventObject->invisible = ((sprite->data[2] & 0x2) >> 1); + objectEvent->invisible = ((sprite->data[2] & 0x2) >> 1); sprite->animPaused = TRUE; if (sprite->data[2] > 64) { - get_berry_tree_graphics(eventObject, sprite); + get_berry_tree_graphics(objectEvent, sprite); sprite->data[1] = 4; sprite->data[2] = 0; return TRUE; @@ -2961,10 +2961,10 @@ bool8 MovementType_BerryTreeGrowth_Step3(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementType_BerryTreeGrowth_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_BerryTreeGrowth_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->data[2]++; - eventObject->invisible = ((sprite->data[2] & 0x2) >> 1); + objectEvent->invisible = ((sprite->data[2] & 0x2) >> 1); sprite->animPaused = TRUE; if (sprite->data[2] > 64) { @@ -2977,34 +2977,34 @@ bool8 MovementType_BerryTreeGrowth_Step4(struct EventObject *eventObject, struct movement_type_def(MovementType_FaceDownAndUp, gMovementTypeFuncs_FaceDownAndUp); -bool8 MovementType_FaceDownAndUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownAndUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownAndUp_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndUp_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysMedium[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceDownAndUp_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndUp_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3012,51 +3012,51 @@ bool8 MovementType_FaceDownAndUp_Step3(struct EventObject *eventObject, struct S return FALSE; } -bool8 MovementType_FaceDownAndUp_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndUp_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; memcpy(directions, gUpAndDownDirections, sizeof gUpAndDownDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 1); + direction = TryGetTrainerEncounterDirection(objectEvent, 1); if (direction == DIR_NONE) { direction = directions[Random() & 1]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceLeftAndRight, gMovementTypeFuncs_FaceLeftAndRight); -bool8 MovementType_FaceLeftAndRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceLeftAndRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceLeftAndRight_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysMedium[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceLeftAndRight_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3064,51 +3064,51 @@ bool8 MovementType_FaceLeftAndRight_Step3(struct EventObject *eventObject, struc return FALSE; } -bool8 MovementType_FaceLeftAndRight_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; memcpy(directions, gLeftAndRightDirections, sizeof gLeftAndRightDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 2); + direction = TryGetTrainerEncounterDirection(objectEvent, 2); if (direction == DIR_NONE) { direction = directions[Random() & 1]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceUpAndLeft, gMovementTypeFuncs_FaceUpAndLeft); -bool8 MovementType_FaceUpAndLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceUpAndLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceUpAndLeft_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysShort[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceUpAndLeft_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3116,51 +3116,51 @@ bool8 MovementType_FaceUpAndLeft_Step3(struct EventObject *eventObject, struct S return FALSE; } -bool8 MovementType_FaceUpAndLeft_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; memcpy(directions, gUpAndLeftDirections, sizeof gUpAndLeftDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 3); + direction = TryGetTrainerEncounterDirection(objectEvent, 3); if (direction == DIR_NONE) { direction = directions[Random() & 1]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceUpAndRight, gMovementTypeFuncs_FaceUpAndRight); -bool8 MovementType_FaceUpAndRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceUpAndRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceUpAndRight_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysShort[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceUpAndRight_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3168,51 +3168,51 @@ bool8 MovementType_FaceUpAndRight_Step3(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementType_FaceUpAndRight_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; memcpy(directions, gUpAndRightDirections, sizeof gUpAndRightDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 4); + direction = TryGetTrainerEncounterDirection(objectEvent, 4); if (direction == DIR_NONE) { direction = directions[Random() & 1]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceDownAndLeft, gMovementTypeFuncs_FaceDownAndLeft); -bool8 MovementType_FaceDownAndLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownAndLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownAndLeft_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysShort[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceDownAndLeft_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3220,51 +3220,51 @@ bool8 MovementType_FaceDownAndLeft_Step3(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementType_FaceDownAndLeft_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; memcpy(directions, gDownAndLeftDirections, sizeof gDownAndLeftDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 5); + direction = TryGetTrainerEncounterDirection(objectEvent, 5); if (direction == DIR_NONE) { direction = directions[Random() & 1]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceDownAndRight, gMovementTypeFuncs_FaceDownAndRight); -bool8 MovementType_FaceDownAndRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownAndRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownAndRight_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysShort[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceDownAndRight_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3272,51 +3272,51 @@ bool8 MovementType_FaceDownAndRight_Step3(struct EventObject *eventObject, struc return FALSE; } -bool8 MovementType_FaceDownAndRight_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[2]; memcpy(directions, gDownAndRightDirections, sizeof gDownAndRightDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 6); + direction = TryGetTrainerEncounterDirection(objectEvent, 6); if (direction == DIR_NONE) { direction = directions[Random() & 1]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceDownUpAndLeft, gMovementTypeFuncs_FaceDownUpAndLeft); -bool8 MovementType_FaceDownUpAndLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownUpAndLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownUpAndLeft_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndLeft_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysShort[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceDownUpAndLeft_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndLeft_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3324,51 +3324,51 @@ bool8 MovementType_FaceDownUpAndLeft_Step3(struct EventObject *eventObject, stru return FALSE; } -bool8 MovementType_FaceDownUpAndLeft_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndLeft_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; memcpy(directions, gDownUpAndLeftDirections, sizeof gDownUpAndLeftDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 7); + direction = TryGetTrainerEncounterDirection(objectEvent, 7); if (direction == DIR_NONE) { direction = directions[Random() & 3]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceDownUpAndRight, gMovementTypeFuncs_FaceDownUpAndRight); -bool8 MovementType_FaceDownUpAndRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownUpAndRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownUpAndRight_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysShort[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceDownUpAndRight_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3376,51 +3376,51 @@ bool8 MovementType_FaceDownUpAndRight_Step3(struct EventObject *eventObject, str return FALSE; } -bool8 MovementType_FaceDownUpAndRight_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownUpAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; memcpy(directions, gDownUpAndRightDirections, sizeof gDownUpAndRightDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 8); + direction = TryGetTrainerEncounterDirection(objectEvent, 8); if (direction == DIR_NONE) { direction = directions[Random() & 3]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceUpLeftAndRight, gMovementTypeFuncs_FaceUpLeftAndRight); -bool8 MovementType_FaceUpLeftAndRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceUpLeftAndRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceUpLeftAndRight_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysShort[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceUpLeftAndRight_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3428,51 +3428,51 @@ bool8 MovementType_FaceUpLeftAndRight_Step3(struct EventObject *eventObject, str return FALSE; } -bool8 MovementType_FaceUpLeftAndRight_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceUpLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; memcpy(directions, gUpLeftAndRightDirections, sizeof gUpLeftAndRightDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 9); + direction = TryGetTrainerEncounterDirection(objectEvent, 9); if (direction == DIR_NONE) { direction = directions[Random() & 3]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_FaceDownLeftAndRight, gMovementTypeFuncs_FaceDownLeftAndRight); -bool8 MovementType_FaceDownLeftAndRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownLeftAndRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_FaceDownLeftAndRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownLeftAndRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_FaceDownLeftAndRight_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownLeftAndRight_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, gMovementDelaysShort[Random() & 3]); - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_FaceDownLeftAndRight_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownLeftAndRight_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 4; return TRUE; @@ -3480,34 +3480,34 @@ bool8 MovementType_FaceDownLeftAndRight_Step3(struct EventObject *eventObject, s return FALSE; } -bool8 MovementType_FaceDownLeftAndRight_Step4(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_FaceDownLeftAndRight_Step4(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[4]; memcpy(directions, gDownLeftAndRightDirections, sizeof gDownLeftAndRightDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 10); + direction = TryGetTrainerEncounterDirection(objectEvent, 10); if (direction == DIR_NONE) { direction = directions[Random() & 3]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_RotateCounterclockwise, gMovementTypeFuncs_RotateCounterclockwise); -bool8 MovementType_RotateCounterclockwise_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RotateCounterclockwise_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ClearObjectEventMovement(objectEvent, sprite); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_RotateCounterclockwise_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RotateCounterclockwise_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, 48); sprite->data[1] = 2; @@ -3515,43 +3515,43 @@ bool8 MovementType_RotateCounterclockwise_Step1(struct EventObject *eventObject, return FALSE; } -bool8 MovementType_RotateCounterclockwise_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RotateCounterclockwise_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_RotateCounterclockwise_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RotateCounterclockwise_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[5]; memcpy(directions, gCounterclockwiseDirections, sizeof gCounterclockwiseDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 0); + direction = TryGetTrainerEncounterDirection(objectEvent, 0); if (direction == DIR_NONE) { - direction = directions[eventObject->facingDirection]; + direction = directions[objectEvent->facingDirection]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 0; return TRUE; } movement_type_def(MovementType_RotateClockwise, gMovementTypeFuncs_RotateClockwise); -bool8 MovementType_RotateClockwise_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RotateClockwise_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); + ClearObjectEventMovement(objectEvent, sprite); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_RotateClockwise_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RotateClockwise_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { SetMovementDelay(sprite, 0x30); sprite->data[1] = 2; @@ -3559,132 +3559,132 @@ bool8 MovementType_RotateClockwise_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementType_RotateClockwise_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RotateClockwise_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (WaitForMovementDelay(sprite) || EventObjectIsTrainerAndCloseToPlayer(eventObject)) + if (WaitForMovementDelay(sprite) || ObjectEventIsTrainerAndCloseToPlayer(objectEvent)) { sprite->data[1] = 3; } return FALSE; } -bool8 MovementType_RotateClockwise_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RotateClockwise_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; u8 directions[5]; memcpy(directions, gClockwiseDirections, sizeof gClockwiseDirections); - direction = TryGetTrainerEncounterDirection(eventObject, 0); + direction = TryGetTrainerEncounterDirection(objectEvent, 0); if (direction == DIR_NONE) { - direction = directions[eventObject->facingDirection]; + direction = directions[objectEvent->facingDirection]; } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 0; return TRUE; } movement_type_def(MovementType_WalkBackAndForth, gMovementTypeFuncs_WalkBackAndForth); -bool8 MovementType_WalkBackAndForth_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WalkBackAndForth_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MovementType_WalkBackAndForth_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WalkBackAndForth_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 direction; - direction = gInitialMovementTypeFacingDirections[eventObject->movementType]; - if (eventObject->directionSequenceIndex != 0) + direction = gInitialMovementTypeFacingDirections[objectEvent->movementType]; + if (objectEvent->directionSequenceIndex != 0) { direction = GetOppositeDirection(direction); } - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[1] = 2; return TRUE; } -bool8 MovementType_WalkBackAndForth_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WalkBackAndForth_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 collisionState; u8 movementActionId; - if (eventObject->directionSequenceIndex && eventObject->initialCoords.x == eventObject->currentCoords.x && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex && objectEvent->initialCoords.x == objectEvent->currentCoords.x && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 0; - SetEventObjectDirection(eventObject, GetOppositeDirection(eventObject->movementDirection)); + objectEvent->directionSequenceIndex = 0; + SetObjectEventDirection(objectEvent, GetOppositeDirection(objectEvent->movementDirection)); } - collisionState = GetCollisionInDirection(eventObject, eventObject->movementDirection); - movementActionId = GetWalkNormalMovementAction(eventObject->movementDirection); + collisionState = GetCollisionInDirection(objectEvent, objectEvent->movementDirection); + movementActionId = GetWalkNormalMovementAction(objectEvent->movementDirection); if (collisionState == 1) { - eventObject->directionSequenceIndex++; - SetEventObjectDirection(eventObject, GetOppositeDirection(eventObject->movementDirection)); - movementActionId = GetWalkNormalMovementAction(eventObject->movementDirection); - collisionState = GetCollisionInDirection(eventObject, eventObject->movementDirection); + objectEvent->directionSequenceIndex++; + SetObjectEventDirection(objectEvent, GetOppositeDirection(objectEvent->movementDirection)); + movementActionId = GetWalkNormalMovementAction(objectEvent->movementDirection); + collisionState = GetCollisionInDirection(objectEvent, objectEvent->movementDirection); } if (collisionState != 0) { - movementActionId = GetWalkInPlaceNormalMovementAction(eventObject->facingDirection); + movementActionId = GetWalkInPlaceNormalMovementAction(objectEvent->facingDirection); } - EventObjectSetSingleMovement(eventObject, sprite, movementActionId); - eventObject->singleMovementActive = 1; + ObjectEventSetSingleMovement(objectEvent, sprite, movementActionId); + objectEvent->singleMovementActive = 1; sprite->data[1] = 3; return TRUE; } -bool8 MovementType_WalkBackAndForth_Step3(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WalkBackAndForth_Step3(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 1; } return FALSE; } -bool8 MovementType_WalkSequence_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WalkSequence_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); sprite->data[1] = 1; return TRUE; } -bool8 MoveNextDirectionInSequence(struct EventObject *eventObject, struct Sprite *sprite, u8 *directionSequence) +bool8 MoveNextDirectionInSequence(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 *directionSequence) { u8 collisionState; u8 movementActionId; - if (eventObject->directionSequenceIndex == 3 && eventObject->initialCoords.x == eventObject->currentCoords.x && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 3 && objectEvent->initialCoords.x == objectEvent->currentCoords.x && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 0; + objectEvent->directionSequenceIndex = 0; } - SetEventObjectDirection(eventObject, directionSequence[eventObject->directionSequenceIndex]); - movementActionId = GetWalkNormalMovementAction(eventObject->movementDirection); - collisionState = GetCollisionInDirection(eventObject, eventObject->movementDirection); + SetObjectEventDirection(objectEvent, directionSequence[objectEvent->directionSequenceIndex]); + movementActionId = GetWalkNormalMovementAction(objectEvent->movementDirection); + collisionState = GetCollisionInDirection(objectEvent, objectEvent->movementDirection); if (collisionState == 1) { - eventObject->directionSequenceIndex++; - SetEventObjectDirection(eventObject, directionSequence[eventObject->directionSequenceIndex]); - movementActionId = GetWalkNormalMovementAction(eventObject->movementDirection); - collisionState = GetCollisionInDirection(eventObject, eventObject->movementDirection); + objectEvent->directionSequenceIndex++; + SetObjectEventDirection(objectEvent, directionSequence[objectEvent->directionSequenceIndex]); + movementActionId = GetWalkNormalMovementAction(objectEvent->movementDirection); + collisionState = GetCollisionInDirection(objectEvent, objectEvent->movementDirection); } if (collisionState != 0) { - movementActionId = GetWalkInPlaceNormalMovementAction(eventObject->facingDirection); + movementActionId = GetWalkInPlaceNormalMovementAction(objectEvent->facingDirection); } - EventObjectSetSingleMovement(eventObject, sprite, movementActionId); - eventObject->singleMovementActive = 1; + ObjectEventSetSingleMovement(objectEvent, sprite, movementActionId); + objectEvent->singleMovementActive = 1; sprite->data[1] = 2; return TRUE; } -bool8 MovementType_WalkSequence_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WalkSequence_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 1; } return FALSE; @@ -3692,560 +3692,560 @@ bool8 MovementType_WalkSequence_Step2(struct EventObject *eventObject, struct Sp movement_type_def(MovementType_WalkSequenceUpRightLeftDown, gMovementTypeFuncs_WalkSequenceUpRightLeftDown); -u8 MovementType_WalkSequenceUpRightLeftDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceUpRightLeftDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gUpRightLeftDownDirections, sizeof gUpRightLeftDownDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceRightLeftDownUp, gMovementTypeFuncs_WalkSequenceRightLeftDownUp); -u8 MovementType_WalkSequenceRightLeftDownUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceRightLeftDownUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gRightLeftDownUpDirections, sizeof gRightLeftDownUpDirections); - if (eventObject->directionSequenceIndex == 1 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 1 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 2; + objectEvent->directionSequenceIndex = 2; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceDownUpRightLeft, gMovementTypeFuncs_WalkSequenceDownUpRightLeft); -u8 MovementType_WalkSequenceDownUpRightLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceDownUpRightLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gDownUpRightLeftDirections, sizeof gDownUpRightLeftDirections); - if (eventObject->directionSequenceIndex == 1 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 1 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 2; + objectEvent->directionSequenceIndex = 2; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceLeftDownUpRight, gMovementTypeFuncs_WalkSequenceLeftDownUpRight); -u8 MovementType_WalkSequenceLeftDownUpRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceLeftDownUpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gLeftDownUpRightDirections, sizeof gLeftDownUpRightDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceUpLeftRightDown, gMovementTypeFuncs_WalkSequenceUpLeftRightDown); -u8 MovementType_WalkSequenceUpLeftRightDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceUpLeftRightDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gUpLeftRightDownDirections, sizeof gUpLeftRightDownDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceLeftRightDownUp, gMovementTypeFuncs_WalkSequenceLeftRightDownUp); -u8 MovementType_WalkSequenceLeftRightDownUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceLeftRightDownUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gLeftRightDownUpDirections, sizeof gLeftRightDownUpDirections); - if (eventObject->directionSequenceIndex == 1 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 1 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 2; + objectEvent->directionSequenceIndex = 2; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceDownUpLeftRight, gMovementTypeFuncs_WalkSequenceDownUpLeftRight); -u8 MovementType_WalkSequenceDownUpLeftRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceDownUpLeftRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gStandardDirections, sizeof gStandardDirections); - if (eventObject->directionSequenceIndex == 1 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 1 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 2; + objectEvent->directionSequenceIndex = 2; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceRightDownUpLeft, gMovementTypeFuncs_WalkSequenceRightDownUpLeft); -u8 MovementType_WalkSequenceRightDownUpLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceRightDownUpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gRightDownUpLeftDirections, sizeof gRightDownUpLeftDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceLeftUpDownRight, gMovementTypeFuncs_WalkSequenceLeftUpDownRight); -u8 MovementType_WalkSequenceLeftUpDownRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceLeftUpDownRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gLeftUpDownRightDirections, sizeof gLeftUpDownRightDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceUpDownRightLeft, gMovementTypeFuncs_WalkSequenceUpDownRightLeft); -u8 MovementType_WalkSequenceUpDownRightLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceUpDownRightLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gUpDownRightLeftDirections, sizeof gUpDownRightLeftDirections); - if (eventObject->directionSequenceIndex == 1 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 1 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 2; + objectEvent->directionSequenceIndex = 2; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceRightLeftUpDown, gMovementTypeFuncs_WalkSequenceRightLeftUpDown); -u8 MovementType_WalkSequenceRightLeftUpDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceRightLeftUpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gRightLeftUpDownDirections, sizeof gRightLeftUpDownDirections); - if (eventObject->directionSequenceIndex == 1 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 1 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 2; + objectEvent->directionSequenceIndex = 2; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceDownRightLeftUp, gMovementTypeFuncs_WalkSequenceDownRightLeftUp); -u8 MovementType_WalkSequenceDownRightLeftUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceDownRightLeftUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gDownRightLeftUpDirections, sizeof gDownRightLeftUpDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceRightUpDownLeft, gMovementTypeFuncs_WalkSequenceRightUpDownLeft); -u8 MovementType_WalkSequenceRightUpDownLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceRightUpDownLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gRightUpDownLeftDirections, sizeof gRightUpDownLeftDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceUpDownLeftRight, gMovementTypeFuncs_WalkSequenceUpDownLeftRight); -u8 MovementType_WalkSequenceUpDownLeftRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceUpDownLeftRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gUpDownLeftRightDirections, sizeof gUpDownLeftRightDirections); - if (eventObject->directionSequenceIndex == 1 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 1 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 2; + objectEvent->directionSequenceIndex = 2; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceLeftRightUpDown, gMovementTypeFuncs_WalkSequenceLeftRightUpDown); -u8 MovementType_WalkSequenceLeftRightUpDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceLeftRightUpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gLeftRightUpDownDirections, sizeof gLeftRightUpDownDirections); - if (eventObject->directionSequenceIndex == 1 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 1 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 2; + objectEvent->directionSequenceIndex = 2; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceDownLeftRightUp, gMovementTypeFuncs_WalkSequenceDownLeftRightUp); -u8 MovementType_WalkSequenceDownLeftRightUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceDownLeftRightUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gDownLeftRightUpDirections, sizeof gDownLeftRightUpDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceUpLeftDownRight, gMovementTypeFuncs_WalkSequenceUpLeftDownRight); -u8 MovementType_WalkSequenceUpLeftDownRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceUpLeftDownRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gUpLeftDownRightDirections, sizeof gUpLeftDownRightDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceDownRightUpLeft, gMovementTypeFuncs_WalkSequenceDownRightUpLeft); -u8 MovementType_WalkSequenceDownRightUpLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceDownRightUpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gDownRightUpLeftDirections, sizeof gDownRightUpLeftDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceLeftDownRightUp, gMovementTypeFuncs_WalkSequenceLeftDownRightUp); -u8 MovementType_WalkSequenceLeftDownRightUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceLeftDownRightUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gLeftDownRightUpDirections, sizeof gLeftDownRightUpDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceRightUpLeftDown, gMovementTypeFuncs_WalkSequenceRightUpLeftDown); -u8 MovementType_WalkSequenceRightUpLeftDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceRightUpLeftDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gRightUpLeftDownDirections, sizeof gRightUpLeftDownDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceUpRightDownLeft, gMovementTypeFuncs_WalkSequenceUpRightDownLeft); -u8 MovementType_WalkSequenceUpRightDownLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceUpRightDownLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gUpRightDownLeftDirections, sizeof gUpRightDownLeftDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceDownLeftUpRight, gMovementTypeFuncs_WalkSequenceDownLeftUpRight); -u8 MovementType_WalkSequenceDownLeftUpRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceDownLeftUpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gDownLeftUpRightDirections, sizeof gDownLeftUpRightDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.y == eventObject->currentCoords.y) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.y == objectEvent->currentCoords.y) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceLeftUpRightDown, gMovementTypeFuncs_WalkSequenceLeftUpRightDown); -u8 MovementType_WalkSequenceLeftUpRightDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceLeftUpRightDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gLeftUpRightDownDirections, sizeof gLeftUpRightDownDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_WalkSequenceRightDownLeftUp, gMovementTypeFuncs_WalkSequenceRightDownLeftUp); -u8 MovementType_WalkSequenceRightDownLeftUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +u8 MovementType_WalkSequenceRightDownLeftUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 directions[4]; memcpy(directions, gRightDownLeftUpDirections, sizeof gRightDownLeftUpDirections); - if (eventObject->directionSequenceIndex == 2 && eventObject->initialCoords.x == eventObject->currentCoords.x) + if (objectEvent->directionSequenceIndex == 2 && objectEvent->initialCoords.x == objectEvent->currentCoords.x) { - eventObject->directionSequenceIndex = 3; + objectEvent->directionSequenceIndex = 3; } - return MoveNextDirectionInSequence(eventObject, sprite, directions); + return MoveNextDirectionInSequence(objectEvent, sprite, directions); } movement_type_def(MovementType_CopyPlayer, gMovementTypeFuncs_CopyPlayer); -bool8 MovementType_CopyPlayer_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_CopyPlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); - if (eventObject->directionSequenceIndex == 0) + ClearObjectEventMovement(objectEvent, sprite); + if (objectEvent->directionSequenceIndex == 0) { - eventObject->directionSequenceIndex = GetPlayerFacingDirection(); + objectEvent->directionSequenceIndex = GetPlayerFacingDirection(); } sprite->data[1] = 1; return TRUE; } -bool8 MovementType_CopyPlayer_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_CopyPlayer_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (gEventObjects[gPlayerAvatar.eventObjectId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == T_TILE_CENTER) + if (gObjectEvents[gPlayerAvatar.objectEventId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == T_TILE_CENTER) { return FALSE; } - return gCopyPlayerMovementFuncs[PlayerGetCopyableMovement()](eventObject, sprite, GetPlayerMovementDirection(), NULL); + return gCopyPlayerMovementFuncs[PlayerGetCopyableMovement()](objectEvent, sprite, GetPlayerMovementDirection(), NULL); } -bool8 MovementType_CopyPlayer_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_CopyPlayer_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; sprite->data[1] = 1; } return FALSE; } -bool8 CopyablePlayerMovement_None(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 CopyablePlayerMovement_None(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { return FALSE; } -bool8 CopyablePlayerMovement_FaceDirection(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 CopyablePlayerMovement_FaceDirection(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, playerDirection))); - eventObject->singleMovementActive = 1; + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, playerDirection))); + objectEvent->singleMovementActive = 1; sprite->data[1] = 2; return TRUE; } -bool8 CopyablePlayerMovement_GoSpeed0(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 CopyablePlayerMovement_GoSpeed0(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); - EventObjectMoveDestCoords(eventObject, direction, &x, &y); - EventObjectSetSingleMovement(eventObject, sprite, GetWalkNormalMovementAction(direction)); - if (GetCollisionAtCoords(eventObject, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, direction); + ObjectEventMoveDestCoords(objectEvent, direction, &x, &y); + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkNormalMovementAction(direction)); + if (GetCollisionAtCoords(objectEvent, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(direction)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(direction)); } - eventObject->singleMovementActive = 1; + objectEvent->singleMovementActive = 1; sprite->data[1] = 2; return TRUE; } -bool8 CopyablePlayerMovement_GoSpeed1(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 CopyablePlayerMovement_GoSpeed1(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); - EventObjectMoveDestCoords(eventObject, direction, &x, &y); - EventObjectSetSingleMovement(eventObject, sprite, GetWalkFastMovementAction(direction)); - if (GetCollisionAtCoords(eventObject, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, direction); + ObjectEventMoveDestCoords(objectEvent, direction, &x, &y); + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkFastMovementAction(direction)); + if (GetCollisionAtCoords(objectEvent, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(direction)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(direction)); } - eventObject->singleMovementActive = TRUE; + objectEvent->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 CopyablePlayerMovement_GoSpeed2(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 CopyablePlayerMovement_GoSpeed2(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); - EventObjectMoveDestCoords(eventObject, direction, &x, &y); - EventObjectSetSingleMovement(eventObject, sprite, GetWalkFastestMovementAction(direction)); - if (GetCollisionAtCoords(eventObject, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, direction); + ObjectEventMoveDestCoords(objectEvent, direction, &x, &y); + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkFastestMovementAction(direction)); + if (GetCollisionAtCoords(objectEvent, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(direction)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(direction)); } - eventObject->singleMovementActive = TRUE; + objectEvent->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 CopyablePlayerMovement_Slide(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 CopyablePlayerMovement_Slide(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); - EventObjectMoveDestCoords(eventObject, direction, &x, &y); - EventObjectSetSingleMovement(eventObject, sprite, GetSlideMovementAction(direction)); - if (GetCollisionAtCoords(eventObject, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, direction); + ObjectEventMoveDestCoords(objectEvent, direction, &x, &y); + ObjectEventSetSingleMovement(objectEvent, sprite, GetSlideMovementAction(direction)); + if (GetCollisionAtCoords(objectEvent, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(direction)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(direction)); } - eventObject->singleMovementActive = TRUE; + objectEvent->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 cph_IM_DIFFERENT(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 cph_IM_DIFFERENT(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); - EventObjectSetSingleMovement(eventObject, sprite, GetJumpInPlaceMovementAction(direction)); - eventObject->singleMovementActive = TRUE; + direction = state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, direction); + ObjectEventSetSingleMovement(objectEvent, sprite, GetJumpInPlaceMovementAction(direction)); + objectEvent->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 CopyablePlayerMovement_GoSpeed4(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 CopyablePlayerMovement_GoSpeed4(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); - EventObjectMoveDestCoords(eventObject, direction, &x, &y); - EventObjectSetSingleMovement(eventObject, sprite, GetJumpMovementAction(direction)); - if (GetCollisionAtCoords(eventObject, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) + direction = state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, direction); + ObjectEventMoveDestCoords(objectEvent, direction, &x, &y); + ObjectEventSetSingleMovement(objectEvent, sprite, GetJumpMovementAction(direction)); + if (GetCollisionAtCoords(objectEvent, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(direction)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(direction)); } - eventObject->singleMovementActive = TRUE; + objectEvent->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } -bool8 CopyablePlayerMovement_Jump(struct EventObject *eventObject, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) +bool8 CopyablePlayerMovement_Jump(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 playerDirection, bool8 tileCallback(u8)) { u32 direction; s16 x; s16 y; direction = playerDirection; - direction = state_to_direction(gInitialMovementTypeFacingDirections[eventObject->movementType], eventObject->directionSequenceIndex, direction); - x = eventObject->currentCoords.x; - y = eventObject->currentCoords.y; + direction = state_to_direction(gInitialMovementTypeFacingDirections[objectEvent->movementType], objectEvent->directionSequenceIndex, direction); + x = objectEvent->currentCoords.x; + y = objectEvent->currentCoords.y; MoveCoordsInDirection(direction, &x, &y, 2, 2); - EventObjectSetSingleMovement(eventObject, sprite, GetJump2MovementAction(direction)); - if (GetCollisionAtCoords(eventObject, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) + ObjectEventSetSingleMovement(objectEvent, sprite, GetJump2MovementAction(direction)); + if (GetCollisionAtCoords(objectEvent, x, y, direction) || (tileCallback != NULL && !tileCallback(MapGridGetMetatileBehaviorAt(x, y)))) { - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(direction)); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(direction)); } - eventObject->singleMovementActive = TRUE; + objectEvent->singleMovementActive = TRUE; sprite->data[1] = 2; return TRUE; } movement_type_def(MovementType_CopyPlayerInGrass, gMovementTypeFuncs_CopyPlayerInGrass); -bool8 MovementType_CopyPlayerInGrass_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_CopyPlayerInGrass_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (gEventObjects[gPlayerAvatar.eventObjectId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == T_TILE_CENTER) + if (gObjectEvents[gPlayerAvatar.objectEventId].movementActionId == 0xFF || gPlayerAvatar.tileTransitionState == T_TILE_CENTER) { return FALSE; } - return gCopyPlayerMovementFuncs[PlayerGetCopyableMovement()](eventObject, sprite, GetPlayerMovementDirection(), MetatileBehavior_IsPokeGrass); + return gCopyPlayerMovementFuncs[PlayerGetCopyableMovement()](objectEvent, sprite, GetPlayerMovementDirection(), MetatileBehavior_IsPokeGrass); } void MovementType_TreeDisguise(struct Sprite *sprite) { - struct EventObject *eventObject; - eventObject = &gEventObjects[sprite->data[0]]; - if (eventObject->directionSequenceIndex == 0 || (eventObject->directionSequenceIndex == 1 && !sprite->data[7])) + struct ObjectEvent *objectEvent; + objectEvent = &gObjectEvents[sprite->data[0]]; + if (objectEvent->directionSequenceIndex == 0 || (objectEvent->directionSequenceIndex == 1 && !sprite->data[7])) { - EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); - eventObject->fieldEffectSpriteId = FieldEffectStart(FLDEFF_TREE_DISGUISE); - eventObject->directionSequenceIndex = 1; + ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + objectEvent->fieldEffectSpriteId = FieldEffectStart(FLDEFF_TREE_DISGUISE); + objectEvent->directionSequenceIndex = 1; sprite->data[7]++; } - UpdateEventObjectCurrentMovement(&gEventObjects[sprite->data[0]], sprite, MovementType_Disguise_Callback); + UpdateObjectEventCurrentMovement(&gObjectEvents[sprite->data[0]], sprite, MovementType_Disguise_Callback); } -static bool8 MovementType_Disguise_Callback(struct EventObject *eventObject, struct Sprite *sprite) +static bool8 MovementType_Disguise_Callback(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); return FALSE; } void MovementType_MountainDisguise(struct Sprite *sprite) { - struct EventObject *eventObject; - eventObject = &gEventObjects[sprite->data[0]]; - if (eventObject->directionSequenceIndex == 0 || (eventObject->directionSequenceIndex == 1 && !sprite->data[7])) + struct ObjectEvent *objectEvent; + objectEvent = &gObjectEvents[sprite->data[0]]; + if (objectEvent->directionSequenceIndex == 0 || (objectEvent->directionSequenceIndex == 1 && !sprite->data[7])) { - EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); - eventObject->fieldEffectSpriteId = FieldEffectStart(FLDEFF_MOUNTAIN_DISGUISE); - eventObject->directionSequenceIndex = 1; + ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + objectEvent->fieldEffectSpriteId = FieldEffectStart(FLDEFF_MOUNTAIN_DISGUISE); + objectEvent->directionSequenceIndex = 1; sprite->data[7]++; } - UpdateEventObjectCurrentMovement(&gEventObjects[sprite->data[0]], sprite, MovementType_Disguise_Callback); + UpdateObjectEventCurrentMovement(&gObjectEvents[sprite->data[0]], sprite, MovementType_Disguise_Callback); } void MovementType_Hidden(struct Sprite *sprite) { if (!sprite->data[7]) { - gEventObjects[sprite->data[0]].fixedPriority = TRUE; + gObjectEvents[sprite->data[0]].fixedPriority = TRUE; sprite->subspriteMode = 2; sprite->oam.priority = 3; sprite->data[7]++; } - UpdateEventObjectCurrentMovement(&gEventObjects[sprite->data[0]], sprite, MovementType_Hidden_Callback); + UpdateObjectEventCurrentMovement(&gObjectEvents[sprite->data[0]], sprite, MovementType_Hidden_Callback); } -static bool8 MovementType_Hidden_Callback(struct EventObject *eventObject, struct Sprite *sprite) +static bool8 MovementType_Hidden_Callback(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - return gMovementTypeFuncs_Hidden[sprite->data[1]](eventObject, sprite); + return gMovementTypeFuncs_Hidden[sprite->data[1]](objectEvent, sprite); } -bool8 MovementType_Hidden_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_Hidden_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); + ClearObjectEventMovement(objectEvent, sprite); return FALSE; } -bool8 MovementType_MoveInPlace_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_MoveInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { sprite->data[1] = 0; } @@ -4254,48 +4254,48 @@ bool8 MovementType_MoveInPlace_Step1(struct EventObject *eventObject, struct Spr movement_type_def(MovementType_WalkInPlace, gMovementTypeFuncs_WalkInPlace); -bool8 MovementType_WalkInPlace_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_WalkInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); - EventObjectSetSingleMovement(eventObject, sprite, GetWalkInPlaceNormalMovementAction(eventObject->facingDirection)); + ClearObjectEventMovement(objectEvent, sprite); + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkInPlaceNormalMovementAction(objectEvent->facingDirection)); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_JogInPlace, gMovementTypeFuncs_JogInPlace); -bool8 MovementType_JogInPlace_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_JogInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); - EventObjectSetSingleMovement(eventObject, sprite, GetWalkInPlaceFastMovementAction(eventObject->facingDirection)); + ClearObjectEventMovement(objectEvent, sprite); + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkInPlaceFastMovementAction(objectEvent->facingDirection)); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_RunInPlace, gMovementTypeFuncs_RunInPlace); -bool8 MovementType_RunInPlace_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_RunInPlace_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); - EventObjectSetSingleMovement(eventObject, sprite, GetWalkInPlaceFastestMovementAction(eventObject->facingDirection)); + ClearObjectEventMovement(objectEvent, sprite); + ObjectEventSetSingleMovement(objectEvent, sprite, GetWalkInPlaceFastestMovementAction(objectEvent->facingDirection)); sprite->data[1] = 1; return TRUE; } movement_type_def(MovementType_Invisible, gMovementTypeFuncs_Invisible); -bool8 MovementType_Invisible_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_Invisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - ClearEventObjectMovement(eventObject, sprite); - EventObjectSetSingleMovement(eventObject, sprite, GetFaceDirectionMovementAction(eventObject->facingDirection)); - eventObject->invisible = TRUE; + ClearObjectEventMovement(objectEvent, sprite); + ObjectEventSetSingleMovement(objectEvent, sprite, GetFaceDirectionMovementAction(objectEvent->facingDirection)); + objectEvent->invisible = TRUE; sprite->data[1] = 1; return TRUE; } -bool8 MovementType_Invisible_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_Invisible_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (EventObjectExecSingleMovementAction(eventObject, sprite)) + if (ObjectEventExecSingleMovementAction(objectEvent, sprite)) { sprite->data[1] = 2; return TRUE; @@ -4303,18 +4303,18 @@ bool8 MovementType_Invisible_Step1(struct EventObject *eventObject, struct Sprit return FALSE; } -bool8 MovementType_Invisible_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementType_Invisible_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->singleMovementActive = 0; + objectEvent->singleMovementActive = 0; return FALSE; } -static void ClearEventObjectMovement(struct EventObject *eventObject, struct Sprite *sprite) +static void ClearObjectEventMovement(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->singleMovementActive = 0; - eventObject->heldMovementActive = FALSE; - eventObject->heldMovementFinished = FALSE; - eventObject->movementActionId = 0xFF; + objectEvent->singleMovementActive = 0; + objectEvent->heldMovementActive = FALSE; + objectEvent->heldMovementFinished = FALSE; + objectEvent->movementActionId = 0xFF; sprite->data[1] = 0; } @@ -4393,9 +4393,9 @@ u8 GetRunningDirectionAnimNum(u8 direction) return gRunningDirectionAnimNums[direction]; } -void sub_805FE28(struct EventObject *eventObject, struct Sprite *sprite, u8 animNum) +void sub_805FE28(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 animNum) { - if (!eventObject->inanimate) + if (!objectEvent->inanimate) { sprite->animNum = animNum; if (sprite->animCmdIndex == 1) @@ -4409,10 +4409,10 @@ void sub_805FE28(struct EventObject *eventObject, struct Sprite *sprite, u8 anim } } -void sub_805FE64(struct EventObject *eventObject, struct Sprite *sprite, u8 animNum) +void sub_805FE64(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 animNum) { u8 animCmdIndex; - if (!eventObject->inanimate) + if (!objectEvent->inanimate) { sprite->animNum = animNum; animCmdIndex = 3; @@ -4435,13 +4435,13 @@ static u8 GetDirectionToFace(s16 x1, s16 y1, s16 x2, s16 y2) return DIR_SOUTH; } -void SetTrainerMovementType(struct EventObject *eventObject, u8 movementType) +void SetTrainerMovementType(struct ObjectEvent *objectEvent, u8 movementType) { - eventObject->movementType = movementType; - eventObject->directionSequenceIndex = 0; - eventObject->playerCopyableMovement = 0; - gSprites[eventObject->spriteId].callback = sMovementTypeCallbacks[movementType]; - gSprites[eventObject->spriteId].data[1] = 0; + objectEvent->movementType = movementType; + objectEvent->directionSequenceIndex = 0; + objectEvent->playerCopyableMovement = 0; + gSprites[objectEvent->spriteId].callback = sMovementTypeCallbacks[movementType]; + gSprites[objectEvent->spriteId].data[1] = 0; } u8 GetTrainerFacingDirectionMovementType(u8 direction) @@ -4449,73 +4449,73 @@ u8 GetTrainerFacingDirectionMovementType(u8 direction) return gTrainerFacingDirectionMovementTypes[direction]; } -static u8 GetCollisionInDirection(struct EventObject *eventObject, u8 direction) +static u8 GetCollisionInDirection(struct ObjectEvent *objectEvent, u8 direction) { s16 x; s16 y; - x = eventObject->currentCoords.x; - y = eventObject->currentCoords.y; + x = objectEvent->currentCoords.x; + y = objectEvent->currentCoords.y; MoveCoords(direction, &x, &y); - return GetCollisionAtCoords(eventObject, x, y, direction); + return GetCollisionAtCoords(objectEvent, x, y, direction); } -u8 GetCollisionAtCoords(struct EventObject *eventObject, s16 x, s16 y, u32 dirn) +u8 GetCollisionAtCoords(struct ObjectEvent *objectEvent, s16 x, s16 y, u32 dirn) { u8 direction; direction = dirn; - if (IsCoordOutsideEventObjectMovementRange(eventObject, x, y)) + if (IsCoordOutsideObjectEventMovementRange(objectEvent, x, y)) return 1; - else if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(eventObject, x, y, direction)) + else if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(objectEvent, x, y, direction)) return 2; - else if (eventObject->trackedByCamera && !CanCameraMoveInDirection(direction)) + else if (objectEvent->trackedByCamera && !CanCameraMoveInDirection(direction)) return 2; - else if (IsZCoordMismatchAt(eventObject->currentElevation, x, y)) + else if (IsZCoordMismatchAt(objectEvent->currentElevation, x, y)) return 3; - else if (DoesObjectCollideWithObjectAt(eventObject, x, y)) + else if (DoesObjectCollideWithObjectAt(objectEvent, x, y)) return 4; return 0; } -u8 GetCollisionFlagsAtCoords(struct EventObject *eventObject, s16 x, s16 y, u8 direction) +u8 GetCollisionFlagsAtCoords(struct ObjectEvent *objectEvent, s16 x, s16 y, u8 direction) { u8 flags = 0; - if (IsCoordOutsideEventObjectMovementRange(eventObject, x, y)) + if (IsCoordOutsideObjectEventMovementRange(objectEvent, x, y)) flags |= 1; - if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(eventObject, x, y, direction) || (eventObject->trackedByCamera && !CanCameraMoveInDirection(direction))) + if (MapGridIsImpassableAt(x, y) || GetMapBorderIdAt(x, y) == -1 || IsMetatileDirectionallyImpassable(objectEvent, x, y, direction) || (objectEvent->trackedByCamera && !CanCameraMoveInDirection(direction))) flags |= 2; - if (IsZCoordMismatchAt(eventObject->currentElevation, x, y)) + if (IsZCoordMismatchAt(objectEvent->currentElevation, x, y)) flags |= 4; - if (DoesObjectCollideWithObjectAt(eventObject, x, y)) + if (DoesObjectCollideWithObjectAt(objectEvent, x, y)) flags |= 8; return flags; } -static bool8 IsCoordOutsideEventObjectMovementRange(struct EventObject *eventObject, s16 x, s16 y) +static bool8 IsCoordOutsideObjectEventMovementRange(struct ObjectEvent *objectEvent, s16 x, s16 y) { s16 minv; s16 maxv; - if (eventObject->range.as_nybbles.x != 0) + if (objectEvent->range.as_nybbles.x != 0) { - minv = eventObject->initialCoords.x - (eventObject->range.as_nybbles.x); - maxv = eventObject->initialCoords.x + (eventObject->range.as_nybbles.x); + minv = objectEvent->initialCoords.x - (objectEvent->range.as_nybbles.x); + maxv = objectEvent->initialCoords.x + (objectEvent->range.as_nybbles.x); if (minv > x || maxv < x) return TRUE; } - if (eventObject->range.as_nybbles.y != 0) + if (objectEvent->range.as_nybbles.y != 0) { - minv = eventObject->initialCoords.y - (eventObject->range.as_nybbles.y); - maxv = eventObject->initialCoords.y + (eventObject->range.as_nybbles.y); + minv = objectEvent->initialCoords.y - (objectEvent->range.as_nybbles.y); + maxv = objectEvent->initialCoords.y + (objectEvent->range.as_nybbles.y); if (minv > y || maxv < y) return TRUE; } return FALSE; } -static bool8 IsMetatileDirectionallyImpassable(struct EventObject *eventObject, s16 x, s16 y, u8 direction) +static bool8 IsMetatileDirectionallyImpassable(struct ObjectEvent *objectEvent, s16 x, s16 y, u8 direction) { - if (gOppositeDirectionBlockedMetatileFuncs[direction - 1](eventObject->currentMetatileBehavior) + if (gOppositeDirectionBlockedMetatileFuncs[direction - 1](objectEvent->currentMetatileBehavior) || gDirectionBlockedMetatileFuncs[direction - 1](MapGridGetMetatileBehaviorAt(x, y))) { return TRUE; @@ -4523,18 +4523,18 @@ static bool8 IsMetatileDirectionallyImpassable(struct EventObject *eventObject, return FALSE; } -static bool8 DoesObjectCollideWithObjectAt(struct EventObject *eventObject, s16 x, s16 y) +static bool8 DoesObjectCollideWithObjectAt(struct ObjectEvent *objectEvent, s16 x, s16 y) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) { - struct EventObject *eventObject2 = &gEventObjects[i]; + struct ObjectEvent *objectEvent2 = &gObjectEvents[i]; - if (eventObject2->active && eventObject2 != eventObject) + if (objectEvent2->active && objectEvent2 != objectEvent) { - if (((eventObject2->currentCoords.x == x && eventObject2->currentCoords.y == y) || (eventObject2->previousCoords.x == x && eventObject2->previousCoords.y == y)) - && AreZCoordsCompatible(eventObject->currentElevation, eventObject2->currentElevation)) + if (((objectEvent2->currentCoords.x == x && objectEvent2->currentCoords.y == y) || (objectEvent2->previousCoords.x == x && objectEvent2->previousCoords.y == y)) + && AreZCoordsCompatible(objectEvent->currentElevation, objectEvent2->currentElevation)) return TRUE; } } @@ -4543,10 +4543,10 @@ static bool8 DoesObjectCollideWithObjectAt(struct EventObject *eventObject, s16 bool8 IsBerryTreeSparkling(u8 localId, u8 mapNum, u8 mapGroup) { - u8 eventObjectId; + u8 objectEventId; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) - if (gSprites[gEventObjects[eventObjectId].spriteId].data[7] & 2) + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) + if (gSprites[gObjectEvents[objectEventId].spriteId].data[7] & 2) return TRUE; return FALSE; @@ -4554,10 +4554,10 @@ bool8 IsBerryTreeSparkling(u8 localId, u8 mapNum, u8 mapGroup) void sub_8060288(u8 localId, u8 mapNum, u8 mapGroup) { - u8 eventObjectId; - if (!TryGetEventObjectIdByLocalIdAndMap(localId, mapNum, mapGroup, &eventObjectId)) + u8 objectEventId; + if (!TryGetObjectEventIdByLocalIdAndMap(localId, mapNum, mapGroup, &objectEventId)) { - gSprites[gEventObjects[eventObjectId].spriteId].data[7] |= 4; + gSprites[gObjectEvents[objectEventId].spriteId].data[7] |= 4; } } @@ -4629,7 +4629,7 @@ void sub_8060470(s16 *x, s16 *y, s16 dx, s16 dy) *y += dy; } -static void GetEventObjectMovingCameraOffset(s16 *x, s16 *y) +static void GetObjectEventMovingCameraOffset(s16 *x, s16 *y) { *x = 0; *y = 0; @@ -4651,107 +4651,107 @@ static void GetEventObjectMovingCameraOffset(s16 *x, s16 *y) } } -void EventObjectMoveDestCoords(struct EventObject *eventObject, u32 direction, s16 *x, s16 *y) +void ObjectEventMoveDestCoords(struct ObjectEvent *objectEvent, u32 direction, s16 *x, s16 *y) { u8 newDirn = direction; - *x = eventObject->currentCoords.x; - *y = eventObject->currentCoords.y; + *x = objectEvent->currentCoords.x; + *y = objectEvent->currentCoords.y; MoveCoords(newDirn, x, y); } -bool8 EventObjectIsMovementOverridden(struct EventObject *eventObject) +bool8 ObjectEventIsMovementOverridden(struct ObjectEvent *objectEvent) { - if (eventObject->singleMovementActive || eventObject->heldMovementActive) + if (objectEvent->singleMovementActive || objectEvent->heldMovementActive) return TRUE; return FALSE; } -bool8 EventObjectIsHeldMovementActive(struct EventObject *eventObject) +bool8 ObjectEventIsHeldMovementActive(struct ObjectEvent *objectEvent) { - if (eventObject->heldMovementActive && eventObject->movementActionId != 0xFF) + if (objectEvent->heldMovementActive && objectEvent->movementActionId != 0xFF) return TRUE; return FALSE; } -bool8 EventObjectSetHeldMovement(struct EventObject *eventObject, u8 movementActionId) +bool8 ObjectEventSetHeldMovement(struct ObjectEvent *objectEvent, u8 movementActionId) { - if (EventObjectIsMovementOverridden(eventObject)) + if (ObjectEventIsMovementOverridden(objectEvent)) return TRUE; - UnfreezeEventObject(eventObject); - eventObject->movementActionId = movementActionId; - eventObject->heldMovementActive = TRUE; - eventObject->heldMovementFinished = FALSE; - gSprites[eventObject->spriteId].data[2] = 0; + UnfreezeObjectEvent(objectEvent); + objectEvent->movementActionId = movementActionId; + objectEvent->heldMovementActive = TRUE; + objectEvent->heldMovementFinished = FALSE; + gSprites[objectEvent->spriteId].data[2] = 0; return FALSE; } -void EventObjectForceSetHeldMovement(struct EventObject *eventObject, u8 movementActionId) +void ObjectEventForceSetHeldMovement(struct ObjectEvent *objectEvent, u8 movementActionId) { - EventObjectClearHeldMovementIfActive(eventObject); - EventObjectSetHeldMovement(eventObject, movementActionId); + ObjectEventClearHeldMovementIfActive(objectEvent); + ObjectEventSetHeldMovement(objectEvent, movementActionId); } -void EventObjectClearHeldMovementIfActive(struct EventObject *eventObject) +void ObjectEventClearHeldMovementIfActive(struct ObjectEvent *objectEvent) { - if (eventObject->heldMovementActive) - EventObjectClearHeldMovement(eventObject); + if (objectEvent->heldMovementActive) + ObjectEventClearHeldMovement(objectEvent); } -void EventObjectClearHeldMovement(struct EventObject *eventObject) +void ObjectEventClearHeldMovement(struct ObjectEvent *objectEvent) { - eventObject->movementActionId = 0xFF; - eventObject->heldMovementActive = FALSE; - eventObject->heldMovementFinished = FALSE; - gSprites[eventObject->spriteId].data[1] = 0; - gSprites[eventObject->spriteId].data[2] = 0; + objectEvent->movementActionId = 0xFF; + objectEvent->heldMovementActive = FALSE; + objectEvent->heldMovementFinished = FALSE; + gSprites[objectEvent->spriteId].data[1] = 0; + gSprites[objectEvent->spriteId].data[2] = 0; } -bool8 EventObjectCheckHeldMovementStatus(struct EventObject *eventObject) +bool8 ObjectEventCheckHeldMovementStatus(struct ObjectEvent *objectEvent) { - if (eventObject->heldMovementActive) - return eventObject->heldMovementFinished; + if (objectEvent->heldMovementActive) + return objectEvent->heldMovementFinished; return 16; } -bool8 EventObjectClearHeldMovementIfFinished(struct EventObject *eventObject) +bool8 ObjectEventClearHeldMovementIfFinished(struct ObjectEvent *objectEvent) { - u8 heldMovementStatus = EventObjectCheckHeldMovementStatus(eventObject); + u8 heldMovementStatus = ObjectEventCheckHeldMovementStatus(objectEvent); if (heldMovementStatus != 0 && heldMovementStatus != 16) - EventObjectClearHeldMovementIfActive(eventObject); + ObjectEventClearHeldMovementIfActive(objectEvent); return heldMovementStatus; } -u8 EventObjectGetHeldMovementActionId(struct EventObject *eventObject) +u8 ObjectEventGetHeldMovementActionId(struct ObjectEvent *objectEvent) { - if (eventObject->heldMovementActive) - return eventObject->movementActionId; + if (objectEvent->heldMovementActive) + return objectEvent->movementActionId; return 0xFF; } -void UpdateEventObjectCurrentMovement(struct EventObject *eventObject, struct Sprite *sprite, u8 (*callback)(struct EventObject *, struct Sprite *)) +void UpdateObjectEventCurrentMovement(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 (*callback)(struct ObjectEvent *, struct Sprite *)) { - DoGroundEffects_OnSpawn(eventObject, sprite); - TryEnableEventObjectAnim(eventObject, sprite); - if (EventObjectIsHeldMovementActive(eventObject)) + DoGroundEffects_OnSpawn(objectEvent, sprite); + TryEnableObjectEventAnim(objectEvent, sprite); + if (ObjectEventIsHeldMovementActive(objectEvent)) { - EventObjectExecHeldMovementAction(eventObject, sprite); + ObjectEventExecHeldMovementAction(objectEvent, sprite); } - else if (!eventObject->frozen) + else if (!objectEvent->frozen) { - while (callback(eventObject, sprite)); + while (callback(objectEvent, sprite)); } - DoGroundEffects_OnBeginStep(eventObject, sprite); - DoGroundEffects_OnFinishStep(eventObject, sprite); - UpdateEventObjectSpriteAnimPause(eventObject, sprite); - UpdateEventObjectVisibility(eventObject, sprite); - EventObjectUpdateSubpriority(eventObject, sprite); + DoGroundEffects_OnBeginStep(objectEvent, sprite); + DoGroundEffects_OnFinishStep(objectEvent, sprite); + UpdateObjectEventSpriteAnimPause(objectEvent, sprite); + UpdateObjectEventVisibility(objectEvent, sprite); + ObjectEventUpdateSubpriority(objectEvent, sprite); } #define dirn_to_anim(name, table)\ @@ -4783,9 +4783,9 @@ dirn_to_anim(GetWalkInPlaceNormalMovementAction, gWalkInPlaceNormalMovementActio dirn_to_anim(GetWalkInPlaceFastMovementAction, gWalkInPlaceFastMovementActions) dirn_to_anim(GetWalkInPlaceFastestMovementAction, gWalkInPlaceFastestMovementActions) -u8 EventObjectFaceOppositeDirection(struct EventObject *eventObject, u8 direction) +u8 ObjectEventFaceOppositeDirection(struct ObjectEvent *objectEvent, u8 direction) { - return EventObjectSetHeldMovement(eventObject, GetFaceDirectionMovementAction(GetOppositeDirection(direction))); + return ObjectEventSetHeldMovement(objectEvent, GetFaceDirectionMovementAction(GetOppositeDirection(direction))); } u8 GetAcroWheelieFaceDirectionMovementAction(u8 direction) @@ -4927,19 +4927,19 @@ u32 state_to_direction(u8 a0, u32 a1, u32 a2) return gUnknown_08375767[a0 - 1][zffuOffset - 1]; } -static void EventObjectExecHeldMovementAction(struct EventObject *eventObject, struct Sprite *sprite) +static void ObjectEventExecHeldMovementAction(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (gMovementActionFuncs[eventObject->movementActionId][sprite->data[2]](eventObject, sprite)) + if (gMovementActionFuncs[objectEvent->movementActionId][sprite->data[2]](objectEvent, sprite)) { - eventObject->heldMovementFinished = TRUE; + objectEvent->heldMovementFinished = TRUE; } } -static bool8 EventObjectExecSingleMovementAction(struct EventObject *eventObject, struct Sprite *sprite) +static bool8 ObjectEventExecSingleMovementAction(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (gMovementActionFuncs[eventObject->movementActionId][sprite->data[2]](eventObject, sprite)) + if (gMovementActionFuncs[objectEvent->movementActionId][sprite->data[2]](objectEvent, sprite)) { - eventObject->movementActionId = 0xFF; + objectEvent->movementActionId = 0xFF; sprite->data[2] = 0; return TRUE; } @@ -4947,135 +4947,135 @@ static bool8 EventObjectExecSingleMovementAction(struct EventObject *eventObject return FALSE; } -static void EventObjectSetSingleMovement(struct EventObject *eventObject, struct Sprite *sprite, u8 movementActionId) +static void ObjectEventSetSingleMovement(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 movementActionId) { - eventObject->movementActionId = movementActionId; + objectEvent->movementActionId = movementActionId; sprite->data[2] = 0; } -static void FaceDirection(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) +static void FaceDirection(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction) { - SetEventObjectDirection(eventObject, direction); - ShiftStillEventObjectCoords(eventObject); - sub_805FE64(eventObject, sprite, GetMoveDirectionAnimNum(eventObject->facingDirection)); + SetObjectEventDirection(objectEvent, direction); + ShiftStillObjectEventCoords(objectEvent); + sub_805FE64(objectEvent, sprite, GetMoveDirectionAnimNum(objectEvent->facingDirection)); sprite->animPaused = TRUE; sprite->data[2] = 1; } -bool8 MovementAction_FaceDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_FaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - FaceDirection(eventObject, sprite, DIR_SOUTH); + FaceDirection(objectEvent, sprite, DIR_SOUTH); return TRUE; } -bool8 MovementAction_FaceUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_FaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - FaceDirection(eventObject, sprite, DIR_NORTH); + FaceDirection(objectEvent, sprite, DIR_NORTH); return TRUE; } -bool8 MovementAction_FaceLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_FaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - FaceDirection(eventObject, sprite, DIR_WEST); + FaceDirection(objectEvent, sprite, DIR_WEST); return TRUE; } -bool8 MovementAction_FaceRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_FaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - FaceDirection(eventObject, sprite, DIR_EAST); + FaceDirection(objectEvent, sprite, DIR_EAST); return TRUE; } -void npc_apply_direction(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) +void npc_apply_direction(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 speed) { s16 x; s16 y; - x = eventObject->currentCoords.x; - y = eventObject->currentCoords.y; - SetEventObjectDirection(eventObject, direction); + x = objectEvent->currentCoords.x; + y = objectEvent->currentCoords.y; + SetObjectEventDirection(objectEvent, direction); MoveCoords(direction, &x, &y); - ShiftEventObjectCoords(eventObject, x, y); + ShiftObjectEventCoords(objectEvent, x, y); oamt_npc_ministep_reset(sprite, direction, speed); sprite->animPaused = FALSE; - eventObject->triggerGroundEffectsOnMove = TRUE; + objectEvent->triggerGroundEffectsOnMove = TRUE; sprite->data[2] = 1; } extern u8 (*const gUnknown_083759C0[5])(u8); -void do_go_anim(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) +void do_go_anim(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 speed) { u8 (*const functions[5])(u8); memcpy((void *)functions, gUnknown_083759C0, sizeof(gUnknown_083759C0)); - npc_apply_direction(eventObject, sprite, direction, speed); - sub_805FE28(eventObject, sprite, functions[speed](eventObject->facingDirection)); + npc_apply_direction(objectEvent, sprite, direction, speed); + sub_805FE28(objectEvent, sprite, functions[speed](objectEvent->facingDirection)); } -void StartRunningAnim(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) +void StartRunningAnim(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction) { - npc_apply_direction(eventObject, sprite, direction, 1); - sub_805FE28(eventObject, sprite, GetRunningDirectionAnimNum(eventObject->facingDirection)); + npc_apply_direction(objectEvent, sprite, direction, 1); + sub_805FE28(objectEvent, sprite, GetRunningDirectionAnimNum(objectEvent->facingDirection)); } bool8 obj_npc_ministep(struct Sprite *); -bool8 npc_obj_ministep_stop_on_arrival(struct EventObject *eventObject, struct Sprite *sprite) +bool8 npc_obj_ministep_stop_on_arrival(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (obj_npc_ministep(sprite)) { - ShiftStillEventObjectCoords(eventObject); - eventObject->triggerGroundEffectsOnStop = TRUE; + ShiftStillObjectEventCoords(objectEvent); + objectEvent->triggerGroundEffectsOnStop = TRUE; sprite->animPaused = TRUE; return TRUE; } return FALSE; } -void sub_8060E68(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) +void sub_8060E68(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction) { s16 x; s16 y; - x = eventObject->currentCoords.x; - y = eventObject->currentCoords.y; - SetEventObjectDirection(eventObject, direction); + x = objectEvent->currentCoords.x; + y = objectEvent->currentCoords.y; + SetObjectEventDirection(objectEvent, direction); MoveCoords(direction, &x, &y); - ShiftEventObjectCoords(eventObject, x, y); + ShiftObjectEventCoords(objectEvent, x, y); sub_806467C(sprite, direction); sprite->animPaused = FALSE; - eventObject->triggerGroundEffectsOnMove = TRUE; + objectEvent->triggerGroundEffectsOnMove = TRUE; sprite->data[2] = 1; } -void sub_8060ED8(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) +void sub_8060ED8(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction) { - sub_8060E68(eventObject, sprite, direction); - sub_805FE28(eventObject, sprite, GetMoveDirectionAnimNum(eventObject->facingDirection)); + sub_8060E68(objectEvent, sprite, direction); + sub_805FE28(objectEvent, sprite, GetMoveDirectionAnimNum(objectEvent->facingDirection)); } -bool8 an_walk_any_2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 an_walk_any_2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sub_806468C(sprite)) { - ShiftStillEventObjectCoords(eventObject); - eventObject->triggerGroundEffectsOnStop = TRUE; + ShiftStillObjectEventCoords(objectEvent); + objectEvent->triggerGroundEffectsOnStop = TRUE; sprite->animPaused = TRUE; return TRUE; } return FALSE; } -bool8 MovementAction_WalkSlowDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkSlowDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkSlowDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkSlowDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8060ED8(eventObject, sprite, DIR_SOUTH); - return MovementAction_WalkSlowDown_Step1(eventObject, sprite); + sub_8060ED8(objectEvent, sprite, DIR_SOUTH); + return MovementAction_WalkSlowDown_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkSlowDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkSlowDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (an_walk_any_2(eventObject, sprite)) + if (an_walk_any_2(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5083,17 +5083,17 @@ bool8 MovementAction_WalkSlowDown_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_WalkSlowUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkSlowUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkSlowUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkSlowUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8060ED8(eventObject, sprite, DIR_NORTH); - return MovementAction_WalkSlowUp_Step1(eventObject, sprite); + sub_8060ED8(objectEvent, sprite, DIR_NORTH); + return MovementAction_WalkSlowUp_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkSlowUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkSlowUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (an_walk_any_2(eventObject, sprite)) + if (an_walk_any_2(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5101,17 +5101,17 @@ bool8 MovementAction_WalkSlowUp_Step1(struct EventObject *eventObject, struct Sp return FALSE; } -bool8 MovementAction_WalkSlowLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkSlowLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkSlowLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkSlowLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8060ED8(eventObject, sprite, DIR_WEST); - return MovementAction_WalkSlowLeft_Step1(eventObject, sprite); + sub_8060ED8(objectEvent, sprite, DIR_WEST); + return MovementAction_WalkSlowLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkSlowLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkSlowLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (an_walk_any_2(eventObject, sprite)) + if (an_walk_any_2(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5119,17 +5119,17 @@ bool8 MovementAction_WalkSlowLeft_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_WalkSlowRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkSlowRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkSlowRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkSlowRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8060ED8(eventObject, sprite, DIR_EAST); - return MovementAction_WalkSlowRight_Step1(eventObject, sprite); + sub_8060ED8(objectEvent, sprite, DIR_EAST); + return MovementAction_WalkSlowRight_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkSlowRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkSlowRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (an_walk_any_2(eventObject, sprite)) + if (an_walk_any_2(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5137,17 +5137,17 @@ bool8 MovementAction_WalkSlowRight_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_WalkNormalDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkNormalDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkNormalDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkNormalDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_SOUTH, 0); - return MovementAction_WalkNormalDown_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_SOUTH, 0); + return MovementAction_WalkNormalDown_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkNormalDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkNormalDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5155,17 +5155,17 @@ bool8 MovementAction_WalkNormalDown_Step1(struct EventObject *eventObject, struc return FALSE; } -bool8 MovementAction_WalkNormalUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkNormalUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkNormalUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkNormalUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_NORTH, 0); - return MovementAction_WalkNormalUp_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_NORTH, 0); + return MovementAction_WalkNormalUp_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkNormalUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkNormalUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5173,17 +5173,17 @@ bool8 MovementAction_WalkNormalUp_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_WalkNormalLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkNormalLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkNormalLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkNormalLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_WEST, 0); - return MovementAction_WalkNormalLeft_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_WEST, 0); + return MovementAction_WalkNormalLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkNormalLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkNormalLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5191,17 +5191,17 @@ bool8 MovementAction_WalkNormalLeft_Step1(struct EventObject *eventObject, struc return FALSE; } -bool8 MovementAction_WalkNormalRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkNormalRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkNormalRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkNormalRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_EAST, 0); - return MovementAction_WalkNormalRight_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_EAST, 0); + return MovementAction_WalkNormalRight_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkNormalRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkNormalRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5209,7 +5209,7 @@ bool8 MovementAction_WalkNormalRight_Step1(struct EventObject *eventObject, stru return FALSE; } -void sub_806113C(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 a4, u8 a5) +void sub_806113C(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 a4, u8 a5) { s16 vSPp4[3]; s16 x; @@ -5217,24 +5217,24 @@ void sub_806113C(struct EventObject *eventObject, struct Sprite *sprite, u8 dire memcpy(vSPp4, gUnknown_08375A34, sizeof gUnknown_08375A34); x = 0; y = 0; - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); MoveCoordsInDirection(direction, &x, &y, vSPp4[a4], vSPp4[a4]); - ShiftEventObjectCoords(eventObject, eventObject->currentCoords.x + x, eventObject->currentCoords.y + y); + ShiftObjectEventCoords(objectEvent, objectEvent->currentCoords.x + x, objectEvent->currentCoords.y + y); sub_80646E4(sprite, direction, a4, a5); sprite->data[2] = 1; sprite->animPaused = 0; - eventObject->triggerGroundEffectsOnMove = 1; - eventObject->disableCoveringGroundEffects = 1; + objectEvent->triggerGroundEffectsOnMove = 1; + objectEvent->disableCoveringGroundEffects = 1; } -void maybe_shadow_1(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 a4, u8 a5) +void maybe_shadow_1(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 a4, u8 a5) { - sub_806113C(eventObject, sprite, direction, a4, a5); - sub_805FE28(eventObject, sprite, GetMoveDirectionAnimNum(eventObject->facingDirection)); - DoShadowFieldEffect(eventObject); + sub_806113C(objectEvent, sprite, direction, a4, a5); + sub_805FE28(objectEvent, sprite, GetMoveDirectionAnimNum(objectEvent->facingDirection)); + DoShadowFieldEffect(objectEvent); } -u8 sub_806123C(struct EventObject *eventObject, struct Sprite *sprite, u8 (*const callback)(struct Sprite *)) +u8 sub_806123C(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 (*const callback)(struct Sprite *)) { s16 vSPp4[3]; s16 x; @@ -5246,54 +5246,54 @@ u8 sub_806123C(struct EventObject *eventObject, struct Sprite *sprite, u8 (*cons { x = 0; y = 0; - MoveCoordsInDirection(eventObject->movementDirection, &x, &y, vSPp4[sprite->data[4]], vSPp4[sprite->data[4]]); - ShiftEventObjectCoords(eventObject, eventObject->currentCoords.x + x, eventObject->currentCoords.y + y); - eventObject->triggerGroundEffectsOnMove = TRUE; - eventObject->disableCoveringGroundEffects = TRUE; + MoveCoordsInDirection(objectEvent->movementDirection, &x, &y, vSPp4[sprite->data[4]], vSPp4[sprite->data[4]]); + ShiftObjectEventCoords(objectEvent, objectEvent->currentCoords.x + x, objectEvent->currentCoords.y + y); + objectEvent->triggerGroundEffectsOnMove = TRUE; + objectEvent->disableCoveringGroundEffects = TRUE; } else if (retval == 0xFF) { - ShiftStillEventObjectCoords(eventObject); - eventObject->triggerGroundEffectsOnStop = TRUE; - eventObject->landingJump = TRUE; + ShiftStillObjectEventCoords(objectEvent); + objectEvent->triggerGroundEffectsOnStop = TRUE; + objectEvent->landingJump = TRUE; sprite->animPaused = TRUE; } return retval; } -u8 sub_8061300(struct EventObject *eventObject, struct Sprite *sprite) +u8 sub_8061300(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - return sub_806123C(eventObject, sprite, sub_8064704); + return sub_806123C(objectEvent, sprite, sub_8064704); } -u8 sub_8061314(struct EventObject *eventObject, struct Sprite *sprite) +u8 sub_8061314(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - return sub_806123C(eventObject, sprite, sub_806478C); + return sub_806123C(objectEvent, sprite, sub_806478C); } -bool8 sub_8061328(struct EventObject *eventObject, struct Sprite *sprite) +bool8 sub_8061328(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061300(eventObject, sprite) == 0xFF) + if (sub_8061300(objectEvent, sprite) == 0xFF) { return TRUE; } return FALSE; } -bool8 sub_8061340(struct EventObject *eventObject, struct Sprite *sprite) +bool8 sub_8061340(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061314(eventObject, sprite) == 0xFF) + if (sub_8061314(objectEvent, sprite) == 0xFF) { return TRUE; } return FALSE; } -bool8 sub_8061358(struct EventObject *eventObject, struct Sprite *sprite) +bool8 sub_8061358(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 retval; - retval = sub_8061300(eventObject, sprite); + retval = sub_8061300(objectEvent, sprite); if (retval != 1) { if (retval == 0xFF) @@ -5302,78 +5302,78 @@ bool8 sub_8061358(struct EventObject *eventObject, struct Sprite *sprite) } return FALSE; } - SetEventObjectDirection(eventObject, GetOppositeDirection(eventObject->movementDirection)); - sub_805FE64(eventObject, sprite, GetMoveDirectionAnimNum(eventObject->facingDirection)); + SetObjectEventDirection(objectEvent, GetOppositeDirection(objectEvent->movementDirection)); + sub_805FE64(objectEvent, sprite, GetMoveDirectionAnimNum(objectEvent->facingDirection)); return FALSE; } -bool8 MovementAction_Jump2Down_Step1(struct EventObject *, struct Sprite *); -bool8 MovementAction_Jump2Up_Step1(struct EventObject *, struct Sprite *); -bool8 MovementAction_Jump2Left_Step1(struct EventObject *, struct Sprite *); -bool8 MovementAction_Jump2Right_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_Jump2Down_Step1(struct ObjectEvent *, struct Sprite *); +bool8 MovementAction_Jump2Up_Step1(struct ObjectEvent *, struct Sprite *); +bool8 MovementAction_Jump2Left_Step1(struct ObjectEvent *, struct Sprite *); +bool8 MovementAction_Jump2Right_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_Jump2Down_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Jump2Down_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_SOUTH, 2, 0); - return MovementAction_Jump2Down_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_SOUTH, 2, 0); + return MovementAction_Jump2Down_Step1(objectEvent, sprite); } -bool8 MovementAction_Jump2Down_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Jump2Down_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_Jump2Up_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Jump2Up_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_NORTH, 2, 0); - return MovementAction_Jump2Up_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_NORTH, 2, 0); + return MovementAction_Jump2Up_Step1(objectEvent, sprite); } -bool8 MovementAction_Jump2Up_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Jump2Up_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_Jump2Left_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Jump2Left_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_WEST, 2, 0); - return MovementAction_Jump2Left_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_WEST, 2, 0); + return MovementAction_Jump2Left_Step1(objectEvent, sprite); } -bool8 MovementAction_Jump2Left_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Jump2Left_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_Jump2Right_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Jump2Right_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_EAST, 2, 0); - return MovementAction_Jump2Right_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_EAST, 2, 0); + return MovementAction_Jump2Right_Step1(objectEvent, sprite); } -bool8 MovementAction_Jump2Right_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Jump2Right_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } @@ -5386,7 +5386,7 @@ void sub_8061508(struct Sprite *sprite, u16 duration) sprite->data[3] = duration; } -bool8 MovementAction_Delay_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Delay_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->data[3]--; if (!sprite->data[3]) @@ -5397,50 +5397,50 @@ bool8 MovementAction_Delay_Step1(struct EventObject *eventObject, struct Sprite return FALSE; } -bool8 MovementAction_Delay1_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Delay1_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8061508(sprite, 1); - return MovementAction_Delay_Step1(eventObject, sprite); + return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_Delay2_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Delay2_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8061508(sprite, 2); - return MovementAction_Delay_Step1(eventObject, sprite); + return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_Delay4_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Delay4_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8061508(sprite, 4); - return MovementAction_Delay_Step1(eventObject, sprite); + return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_Delay8_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Delay8_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8061508(sprite, 8); - return MovementAction_Delay_Step1(eventObject, sprite); + return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_Delay16_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Delay16_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sub_8061508(sprite, 16); - return MovementAction_Delay_Step1(eventObject, sprite); + return MovementAction_Delay_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastDown_Step1(struct EventObject *eventObject, struct Sprite *sprite); -bool8 MovementAction_WalkFastUp_Step1(struct EventObject *eventObject, struct Sprite *sprite); -bool8 MovementAction_WalkFastLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite); -bool8 MovementAction_WalkFastRight_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_WalkFastDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +bool8 MovementAction_WalkFastUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +bool8 MovementAction_WalkFastLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); +bool8 MovementAction_WalkFastRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_WalkFastDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_SOUTH, 1); - return MovementAction_WalkFastDown_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_SOUTH, 1); + return MovementAction_WalkFastDown_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5448,15 +5448,15 @@ bool8 MovementAction_WalkFastDown_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_WalkFastUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_NORTH, 1); - return MovementAction_WalkFastUp_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_NORTH, 1); + return MovementAction_WalkFastUp_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5464,15 +5464,15 @@ bool8 MovementAction_WalkFastUp_Step1(struct EventObject *eventObject, struct Sp return FALSE; } -bool8 MovementAction_WalkFastLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_WEST, 1); - return MovementAction_WalkFastLeft_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_WEST, 1); + return MovementAction_WalkFastLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5480,15 +5480,15 @@ bool8 MovementAction_WalkFastLeft_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_WalkFastRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_EAST, 1); - return MovementAction_WalkFastRight_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_EAST, 1); + return MovementAction_WalkFastRight_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5496,16 +5496,16 @@ bool8 MovementAction_WalkFastRight_Step1(struct EventObject *eventObject, struct return FALSE; } -void sub_80616CC(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 animNum, u16 duration) +void sub_80616CC(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 animNum, u16 duration) { - SetEventObjectDirection(eventObject, direction); - sub_805FE28(eventObject, sprite, animNum); + SetObjectEventDirection(objectEvent, direction); + sub_805FE28(objectEvent, sprite, animNum); sprite->animPaused = FALSE; sprite->data[2] = 1; sprite->data[3] = duration; } -bool8 MovementAction_WalkInPlace_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlace_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->data[3]--; if (sprite->data[3] == 0) @@ -5517,122 +5517,122 @@ bool8 MovementAction_WalkInPlace_Step1(struct EventObject *eventObject, struct S return FALSE; } -bool8 MovementAction_WalkInPlaceSlow_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceSlow_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (sprite->data[3] & 1) { sprite->animDelayCounter++; } - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceSlowDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceSlowDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_SOUTH, GetMoveDirectionAnimNum(DIR_SOUTH), 32); - return MovementAction_WalkInPlaceSlow_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_SOUTH, GetMoveDirectionAnimNum(DIR_SOUTH), 32); + return MovementAction_WalkInPlaceSlow_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceSlowUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceSlowUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_NORTH, GetMoveDirectionAnimNum(DIR_NORTH), 32); - return MovementAction_WalkInPlaceSlow_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_NORTH, GetMoveDirectionAnimNum(DIR_NORTH), 32); + return MovementAction_WalkInPlaceSlow_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceSlowLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceSlowLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_WEST, GetMoveDirectionAnimNum(DIR_WEST), 32); - return MovementAction_WalkInPlaceSlow_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_WEST, GetMoveDirectionAnimNum(DIR_WEST), 32); + return MovementAction_WalkInPlaceSlow_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceSlowRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceSlowRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_EAST, GetMoveDirectionAnimNum(DIR_EAST), 32); - return MovementAction_WalkInPlaceSlow_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_EAST, GetMoveDirectionAnimNum(DIR_EAST), 32); + return MovementAction_WalkInPlaceSlow_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceNormalDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceNormalDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_SOUTH, GetMoveDirectionAnimNum(DIR_SOUTH), 16); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_SOUTH, GetMoveDirectionAnimNum(DIR_SOUTH), 16); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceNormalUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceNormalUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_NORTH, GetMoveDirectionAnimNum(DIR_NORTH), 16); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_NORTH, GetMoveDirectionAnimNum(DIR_NORTH), 16); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceNormalLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceNormalLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_WEST, GetMoveDirectionAnimNum(DIR_WEST), 16); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_WEST, GetMoveDirectionAnimNum(DIR_WEST), 16); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceNormalRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceNormalRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_EAST, GetMoveDirectionAnimNum(DIR_EAST), 16); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_EAST, GetMoveDirectionAnimNum(DIR_EAST), 16); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceFastDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_SOUTH, GetMoveDirectionFastAnimNum(DIR_SOUTH), 8); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_SOUTH, GetMoveDirectionFastAnimNum(DIR_SOUTH), 8); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceFastUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_NORTH, GetMoveDirectionFastAnimNum(DIR_NORTH), 8); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_NORTH, GetMoveDirectionFastAnimNum(DIR_NORTH), 8); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceFastLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_WEST, GetMoveDirectionFastAnimNum(DIR_WEST), 8); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_WEST, GetMoveDirectionFastAnimNum(DIR_WEST), 8); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceFastRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_EAST, GetMoveDirectionFastAnimNum(DIR_EAST), 8); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_EAST, GetMoveDirectionFastAnimNum(DIR_EAST), 8); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastestDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceFastestDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_SOUTH, GetMoveDirectionFasterAnimNum(DIR_SOUTH), 4); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_SOUTH, GetMoveDirectionFasterAnimNum(DIR_SOUTH), 4); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastestUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceFastestUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_NORTH, GetMoveDirectionFasterAnimNum(DIR_NORTH), 4); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_NORTH, GetMoveDirectionFasterAnimNum(DIR_NORTH), 4); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastestLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceFastestLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_WEST, GetMoveDirectionFasterAnimNum(DIR_WEST), 4); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_WEST, GetMoveDirectionFasterAnimNum(DIR_WEST), 4); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkInPlaceFastestRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkInPlaceFastestRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_EAST, GetMoveDirectionFasterAnimNum(DIR_EAST), 4); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_EAST, GetMoveDirectionFasterAnimNum(DIR_EAST), 4); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_RideWaterCurrentDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_RideWaterCurrentDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RideWaterCurrentDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_SOUTH, 2); - return MovementAction_RideWaterCurrentDown_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_SOUTH, 2); + return MovementAction_RideWaterCurrentDown_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RideWaterCurrentDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5641,17 +5641,17 @@ bool8 MovementAction_RideWaterCurrentDown_Step1(struct EventObject *eventObject, } -bool8 MovementAction_RideWaterCurrentUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_RideWaterCurrentUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_RideWaterCurrentUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RideWaterCurrentUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_NORTH, 2); - return MovementAction_RideWaterCurrentUp_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_NORTH, 2); + return MovementAction_RideWaterCurrentUp_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RideWaterCurrentUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5660,17 +5660,17 @@ bool8 MovementAction_RideWaterCurrentUp_Step1(struct EventObject *eventObject, s } -bool8 MovementAction_RideWaterCurrentLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_RideWaterCurrentLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_RideWaterCurrentLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RideWaterCurrentLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_WEST, 2); - return MovementAction_RideWaterCurrentLeft_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_WEST, 2); + return MovementAction_RideWaterCurrentLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RideWaterCurrentLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5679,17 +5679,17 @@ bool8 MovementAction_RideWaterCurrentLeft_Step1(struct EventObject *eventObject, } -bool8 MovementAction_RideWaterCurrentRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_RideWaterCurrentRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_RideWaterCurrentRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RideWaterCurrentRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_EAST, 2); - return MovementAction_RideWaterCurrentRight_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_EAST, 2); + return MovementAction_RideWaterCurrentRight_Step1(objectEvent, sprite); } -bool8 MovementAction_RideWaterCurrentRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RideWaterCurrentRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5697,17 +5697,17 @@ bool8 MovementAction_RideWaterCurrentRight_Step1(struct EventObject *eventObject return FALSE; } -bool8 MovementAction_WalkFastestDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkFastestDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkFastestDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastestDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_SOUTH, 3); - return MovementAction_WalkFastestDown_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_SOUTH, 3); + return MovementAction_WalkFastestDown_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastestDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastestDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5715,17 +5715,17 @@ bool8 MovementAction_WalkFastestDown_Step1(struct EventObject *eventObject, stru return FALSE; } -bool8 MovementAction_WalkFastestUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkFastestUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkFastestUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastestUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_NORTH, 3); - return MovementAction_WalkFastestUp_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_NORTH, 3); + return MovementAction_WalkFastestUp_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastestUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastestUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5734,17 +5734,17 @@ bool8 MovementAction_WalkFastestUp_Step1(struct EventObject *eventObject, struct } -bool8 MovementAction_WalkFastestLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkFastestLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkFastestLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastestLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_WEST, 3); - return MovementAction_WalkFastestLeft_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_WEST, 3); + return MovementAction_WalkFastestLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastestLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastestLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5753,17 +5753,17 @@ bool8 MovementAction_WalkFastestLeft_Step1(struct EventObject *eventObject, stru } -bool8 MovementAction_WalkFastestRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkFastestRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkFastestRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastestRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_EAST, 3); - return MovementAction_WalkFastestRight_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_EAST, 3); + return MovementAction_WalkFastestRight_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkFastestRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkFastestRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5771,17 +5771,17 @@ bool8 MovementAction_WalkFastestRight_Step1(struct EventObject *eventObject, str return FALSE; } -bool8 MovementAction_SlideDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_SlideDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_SlideDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SlideDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_SOUTH, 4); - return MovementAction_SlideDown_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_SOUTH, 4); + return MovementAction_SlideDown_Step1(objectEvent, sprite); } -bool8 MovementAction_SlideDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SlideDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5789,17 +5789,17 @@ bool8 MovementAction_SlideDown_Step1(struct EventObject *eventObject, struct Spr return FALSE; } -bool8 MovementAction_SlideUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_SlideUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_SlideUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SlideUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_NORTH, 4); - return MovementAction_SlideUp_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_NORTH, 4); + return MovementAction_SlideUp_Step1(objectEvent, sprite); } -bool8 MovementAction_SlideUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SlideUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5808,17 +5808,17 @@ bool8 MovementAction_SlideUp_Step1(struct EventObject *eventObject, struct Sprit } -bool8 MovementAction_SlideLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_SlideLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_SlideLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SlideLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_WEST, 4); - return MovementAction_SlideLeft_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_WEST, 4); + return MovementAction_SlideLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_SlideLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SlideLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5827,17 +5827,17 @@ bool8 MovementAction_SlideLeft_Step1(struct EventObject *eventObject, struct Spr } -bool8 MovementAction_SlideRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_SlideRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_SlideRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SlideRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - do_go_anim(eventObject, sprite, DIR_EAST, 4); - return MovementAction_SlideRight_Step1(eventObject, sprite); + do_go_anim(objectEvent, sprite, DIR_EAST, 4); + return MovementAction_SlideRight_Step1(objectEvent, sprite); } -bool8 MovementAction_SlideRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SlideRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5845,17 +5845,17 @@ bool8 MovementAction_SlideRight_Step1(struct EventObject *eventObject, struct Sp return FALSE; } -bool8 MovementAction_PlayerRunDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_PlayerRunDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_PlayerRunDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PlayerRunDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartRunningAnim(eventObject, sprite, DIR_SOUTH); - return MovementAction_PlayerRunDown_Step1(eventObject, sprite); + StartRunningAnim(objectEvent, sprite, DIR_SOUTH); + return MovementAction_PlayerRunDown_Step1(objectEvent, sprite); } -bool8 MovementAction_PlayerRunDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PlayerRunDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5863,17 +5863,17 @@ bool8 MovementAction_PlayerRunDown_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_PlayerRunUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_PlayerRunUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_PlayerRunUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PlayerRunUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartRunningAnim(eventObject, sprite, DIR_NORTH); - return MovementAction_PlayerRunUp_Step1(eventObject, sprite); + StartRunningAnim(objectEvent, sprite, DIR_NORTH); + return MovementAction_PlayerRunUp_Step1(objectEvent, sprite); } -bool8 MovementAction_PlayerRunUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PlayerRunUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5881,17 +5881,17 @@ bool8 MovementAction_PlayerRunUp_Step1(struct EventObject *eventObject, struct S return FALSE; } -bool8 MovementAction_PlayerRunLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_PlayerRunLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_PlayerRunLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PlayerRunLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartRunningAnim(eventObject, sprite, DIR_WEST); - return MovementAction_PlayerRunLeft_Step1(eventObject, sprite); + StartRunningAnim(objectEvent, sprite, DIR_WEST); + return MovementAction_PlayerRunLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_PlayerRunLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PlayerRunLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5899,17 +5899,17 @@ bool8 MovementAction_PlayerRunLeft_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_PlayerRunRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_PlayerRunRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_PlayerRunRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PlayerRunRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartRunningAnim(eventObject, sprite, DIR_EAST); - return MovementAction_PlayerRunRight_Step1(eventObject, sprite); + StartRunningAnim(objectEvent, sprite, DIR_EAST); + return MovementAction_PlayerRunRight_Step1(objectEvent, sprite); } -bool8 MovementAction_PlayerRunRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PlayerRunRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -5917,22 +5917,22 @@ bool8 MovementAction_PlayerRunRight_Step1(struct EventObject *eventObject, struc return FALSE; } -void StartSpriteAnimInDirection(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 animNum) +void StartSpriteAnimInDirection(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 animNum) { SetAndStartSpriteAnim(sprite, animNum, 0); - SetEventObjectDirection(eventObject, direction); + SetObjectEventDirection(objectEvent, direction); sprite->data[2] = 1; } -bool8 MovementAction_StartAnimInDirection_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_StartAnimInDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, eventObject->movementDirection, sprite->animNum); + StartSpriteAnimInDirection(objectEvent, sprite, objectEvent->movementDirection, sprite->animNum); return FALSE; } bool8 SpriteAnimEnded(struct Sprite *); -bool8 MovementAction_WaitSpriteAnim(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WaitSpriteAnim(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (SpriteAnimEnded(sprite)) { @@ -5942,457 +5942,457 @@ bool8 MovementAction_WaitSpriteAnim(struct EventObject *eventObject, struct Spri return FALSE; } -void sub_8061F5C(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) +void sub_8061F5C(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction) { - sub_806113C(eventObject, sprite, direction, 1, 0); + sub_806113C(objectEvent, sprite, direction, 1, 0); StartSpriteAnim(sprite, GetJumpSpecialDirectionAnimNum(direction)); } -bool8 MovementAction_JumpSpecialDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_JumpSpecialDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_JumpSpecialDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpSpecialDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8061F5C(eventObject, sprite, DIR_SOUTH); - return MovementAction_JumpSpecialDown_Step1(eventObject, sprite); + sub_8061F5C(objectEvent, sprite, DIR_SOUTH); + return MovementAction_JumpSpecialDown_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpSpecialDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpSpecialDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061340(eventObject, sprite)) + if (sub_8061340(objectEvent, sprite)) { sprite->data[2] = 2; - eventObject->landingJump = FALSE; + objectEvent->landingJump = FALSE; return TRUE; } return FALSE; } -bool8 MovementAction_JumpSpecialUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_JumpSpecialUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_JumpSpecialUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpSpecialUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8061F5C(eventObject, sprite, DIR_NORTH); - return MovementAction_JumpSpecialUp_Step1(eventObject, sprite); + sub_8061F5C(objectEvent, sprite, DIR_NORTH); + return MovementAction_JumpSpecialUp_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpSpecialUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpSpecialUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061340(eventObject, sprite)) + if (sub_8061340(objectEvent, sprite)) { sprite->data[2] = 2; - eventObject->landingJump = FALSE; + objectEvent->landingJump = FALSE; return TRUE; } return FALSE; } -bool8 MovementAction_JumpSpecialLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_JumpSpecialLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_JumpSpecialLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpSpecialLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8061F5C(eventObject, sprite, DIR_WEST); - return MovementAction_JumpSpecialLeft_Step1(eventObject, sprite); + sub_8061F5C(objectEvent, sprite, DIR_WEST); + return MovementAction_JumpSpecialLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpSpecialLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpSpecialLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061340(eventObject, sprite)) + if (sub_8061340(objectEvent, sprite)) { sprite->data[2] = 2; - eventObject->landingJump = FALSE; + objectEvent->landingJump = FALSE; return TRUE; } return FALSE; } -bool8 MovementAction_JumpSpecialRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_JumpSpecialRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpSpecialRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8061F5C(eventObject, sprite, DIR_EAST); - return MovementAction_JumpSpecialRight_Step1(eventObject, sprite); + sub_8061F5C(objectEvent, sprite, DIR_EAST); + return MovementAction_JumpSpecialRight_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpSpecialRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpSpecialRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061340(eventObject, sprite)) + if (sub_8061340(objectEvent, sprite)) { sprite->data[2] = 2; - eventObject->landingJump = 0; + objectEvent->landingJump = 0; return TRUE; } return FALSE; } -bool8 MovementAction_FacePlayer_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_FacePlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 playerObjectId; - if (!TryGetEventObjectIdByLocalIdAndMap(0xFF, 0, 0, &playerObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(0xFF, 0, 0, &playerObjectId)) { - FaceDirection(eventObject, sprite, GetDirectionToFace(eventObject->currentCoords.x, eventObject->currentCoords.y, gEventObjects[playerObjectId].currentCoords.x, gEventObjects[playerObjectId].currentCoords.y)); + FaceDirection(objectEvent, sprite, GetDirectionToFace(objectEvent->currentCoords.x, objectEvent->currentCoords.y, gObjectEvents[playerObjectId].currentCoords.x, gObjectEvents[playerObjectId].currentCoords.y)); } sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_FaceAwayPlayer_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_FaceAwayPlayer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u8 playerObjectId; - if (!TryGetEventObjectIdByLocalIdAndMap(0xFF, 0, 0, &playerObjectId)) + if (!TryGetObjectEventIdByLocalIdAndMap(0xFF, 0, 0, &playerObjectId)) { - FaceDirection(eventObject, sprite, GetOppositeDirection(GetDirectionToFace(eventObject->currentCoords.x, eventObject->currentCoords.y, gEventObjects[playerObjectId].currentCoords.x, gEventObjects[playerObjectId].currentCoords.y))); + FaceDirection(objectEvent, sprite, GetOppositeDirection(GetDirectionToFace(objectEvent->currentCoords.x, objectEvent->currentCoords.y, gObjectEvents[playerObjectId].currentCoords.x, gObjectEvents[playerObjectId].currentCoords.y))); } sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_LockFacingDirection_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_LockFacingDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->facingDirectionLocked = TRUE; + objectEvent->facingDirectionLocked = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_UnlockFacingDirection_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_UnlockFacingDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->facingDirectionLocked = FALSE; + objectEvent->facingDirectionLocked = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_JumpDown_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_SOUTH, 1, 2); - return MovementAction_JumpDown_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_SOUTH, 1, 2); + return MovementAction_JumpDown_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpUp_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_NORTH, 1, 2); - return MovementAction_JumpUp_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_NORTH, 1, 2); + return MovementAction_JumpUp_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_WEST, 1, 2); - return MovementAction_JumpLeft_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_WEST, 1, 2); + return MovementAction_JumpLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpRight_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_EAST, 1, 2); - return MovementAction_JumpRight_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_EAST, 1, 2); + return MovementAction_JumpRight_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpInPlaceDown_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpInPlaceDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpInPlaceDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_SOUTH, 0, 0); - return MovementAction_JumpInPlaceDown_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_SOUTH, 0, 0); + return MovementAction_JumpInPlaceDown_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpInPlaceUp_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpInPlaceUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpInPlaceUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_NORTH, 0, 0); - return MovementAction_JumpInPlaceUp_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_NORTH, 0, 0); + return MovementAction_JumpInPlaceUp_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpInPlaceLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpInPlaceLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpInPlaceLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_WEST, 0, 0); - return MovementAction_JumpInPlaceLeft_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_WEST, 0, 0); + return MovementAction_JumpInPlaceLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpInPlaceRight_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpInPlaceRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpInPlaceRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_EAST, 0, 0); - return MovementAction_JumpInPlaceRight_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_EAST, 0, 0); + return MovementAction_JumpInPlaceRight_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpInPlaceDownUp_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpInPlaceDownUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpInPlaceDownUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceDownUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_SOUTH, 0, 2); - return MovementAction_JumpInPlaceDownUp_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_SOUTH, 0, 2); + return MovementAction_JumpInPlaceDownUp_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceDownUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceDownUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061358(eventObject, sprite)) + if (sub_8061358(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpInPlaceUpDown_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpInPlaceUpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpInPlaceUpDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceUpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_NORTH, 0, 2); - return MovementAction_JumpInPlaceUpDown_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_NORTH, 0, 2); + return MovementAction_JumpInPlaceUpDown_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceUpDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceUpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061358(eventObject, sprite)) + if (sub_8061358(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpInPlaceLeftRight_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpInPlaceLeftRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpInPlaceLeftRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceLeftRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_WEST, 0, 2); - return MovementAction_JumpInPlaceLeftRight_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_WEST, 0, 2); + return MovementAction_JumpInPlaceLeftRight_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceLeftRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceLeftRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061358(eventObject, sprite)) + if (sub_8061358(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_JumpInPlaceRightLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite); +bool8 MovementAction_JumpInPlaceRightLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite); -bool8 MovementAction_JumpInPlaceRightLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceRightLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - maybe_shadow_1(eventObject, sprite, DIR_EAST, 0, 2); - return MovementAction_JumpInPlaceRightLeft_Step1(eventObject, sprite); + maybe_shadow_1(objectEvent, sprite, DIR_EAST, 0, 2); + return MovementAction_JumpInPlaceRightLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_JumpInPlaceRightLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_JumpInPlaceRightLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061358(eventObject, sprite)) + if (sub_8061358(objectEvent, sprite)) { - eventObject->hasShadow = 0; + objectEvent->hasShadow = 0; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_FaceOriginalDirection_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_FaceOriginalDirection_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - FaceDirection(eventObject, sprite, gInitialMovementTypeFacingDirections[eventObject->movementType]); + FaceDirection(objectEvent, sprite, gInitialMovementTypeFacingDirections[objectEvent->movementType]); return TRUE; } -bool8 MovementAction_NurseJoyBowDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_NurseJoyBowDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_SOUTH, 0x14); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, 0x14); return FALSE; } -bool8 MovementAction_EnableJumpLandingGroundEffect_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_EnableJumpLandingGroundEffect_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->disableJumpLandingGroundEffect = FALSE; + objectEvent->disableJumpLandingGroundEffect = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_DisableJumpLandingGroundEffect_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_DisableJumpLandingGroundEffect_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->disableJumpLandingGroundEffect = TRUE; + objectEvent->disableJumpLandingGroundEffect = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_DisableAnimation_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_DisableAnimation_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->inanimate = TRUE; + objectEvent->inanimate = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_RestoreAnimation_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RestoreAnimation_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->inanimate = GetEventObjectGraphicsInfo(eventObject->graphicsId)->inanimate; + objectEvent->inanimate = GetObjectEventGraphicsInfo(objectEvent->graphicsId)->inanimate; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_SetInvisible_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SetInvisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->invisible = TRUE; + objectEvent->invisible = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_SetVisible_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SetVisible_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->invisible = FALSE; + objectEvent->invisible = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_EmoteExclamationMark_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_EmoteExclamationMark_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_EXCLAMATION_MARK_ICON); sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_EmoteQuestionMark_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_EmoteQuestionMark_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_QUESTION_MARK_ICON); sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_EmoteHeart_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_EmoteHeart_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); FieldEffectStart(FLDEFF_HEART_ICON); sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_RevealTrainer_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_RevealTrainer_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_RevealTrainer_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RevealTrainer_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (eventObject->movementType == MOVEMENT_TYPE_HIDDEN) + if (objectEvent->movementType == MOVEMENT_TYPE_HIDDEN) { - sub_8084794(eventObject); + sub_8084794(objectEvent); return FALSE; } - else if (eventObject->movementType != MOVEMENT_TYPE_TREE_DISGUISE && eventObject->movementType != MOVEMENT_TYPE_MOUNTAIN_DISGUISE) + else if (objectEvent->movementType != MOVEMENT_TYPE_TREE_DISGUISE && objectEvent->movementType != MOVEMENT_TYPE_MOUNTAIN_DISGUISE) { sprite->data[2] = 2; return TRUE; } else { - sub_812869C(eventObject); + sub_812869C(objectEvent); sprite->data[2] = 1; - return MovementAction_RevealTrainer_Step1(eventObject, sprite); + return MovementAction_RevealTrainer_Step1(objectEvent, sprite); } } -bool8 MovementAction_RevealTrainer_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RevealTrainer_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_81286C4(eventObject)) + if (sub_81286C4(objectEvent)) { sprite->data[2] = 2; return TRUE; @@ -6400,14 +6400,14 @@ bool8 MovementAction_RevealTrainer_Step1(struct EventObject *eventObject, struct return FALSE; } -bool8 MovementAction_RockSmashBreak_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RockSmashBreak_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { SetAndStartSpriteAnim(sprite, 1, 0); sprite->data[2] = 1; return FALSE; } -bool8 MovementAction_RockSmashBreak_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RockSmashBreak_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (SpriteAnimEnded(sprite)) { @@ -6417,25 +6417,25 @@ bool8 MovementAction_RockSmashBreak_Step1(struct EventObject *eventObject, struc return FALSE; } -bool8 MovementAction_RockSmashBreak_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_RockSmashBreak_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->invisible ^= TRUE; + objectEvent->invisible ^= TRUE; if (WaitForMovementDelay(sprite)) { - eventObject->invisible = TRUE; + objectEvent->invisible = TRUE; sprite->data[2] = 3; } return FALSE; } -bool8 MovementAction_CutTree_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_CutTree_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { SetAndStartSpriteAnim(sprite, 1, 0); sprite->data[2] = 1; return FALSE; } -bool8 MovementAction_CutTree_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_CutTree_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { if (SpriteAnimEnded(sprite)) { @@ -6445,32 +6445,32 @@ bool8 MovementAction_CutTree_Step1(struct EventObject *eventObject, struct Sprit return FALSE; } -bool8 MovementAction_CutTree_Step2(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_CutTree_Step2(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->invisible ^= TRUE; + objectEvent->invisible ^= TRUE; if (WaitForMovementDelay(sprite)) { - eventObject->invisible = TRUE; + objectEvent->invisible = TRUE; sprite->data[2] = 3; } return FALSE; } -bool8 MovementAction_SetFixedPriority_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_SetFixedPriority_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->fixedPriority = TRUE; + objectEvent->fixedPriority = TRUE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_ClearFixedPriority_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_ClearFixedPriority_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - eventObject->fixedPriority = FALSE; + objectEvent->fixedPriority = FALSE; sprite->data[2] = 1; return TRUE; } -bool8 MovementAction_InitAffineAnim_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_InitAffineAnim_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->oam.affineMode = ST_OAM_AFFINE_DOUBLE; InitSpriteAffineAnim(sprite); @@ -6479,7 +6479,7 @@ bool8 MovementAction_InitAffineAnim_Step0(struct EventObject *eventObject, struc return TRUE; } -bool8 MovementAction_ClearAffineAnim_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_ClearAffineAnim_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { FreeOamMatrix(sprite->oam.matrixNum); sprite->oam.affineMode = ST_OAM_AFFINE_OFF; @@ -6487,19 +6487,19 @@ bool8 MovementAction_ClearAffineAnim_Step0(struct EventObject *eventObject, stru return TRUE; } -bool8 MovementAction_WalkDownStartAffine_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkDownStartAffine_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkDownStartAffine_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkDownStartAffine_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8060ED8(eventObject, sprite, DIR_SOUTH); + sub_8060ED8(objectEvent, sprite, DIR_SOUTH); sprite->affineAnimPaused = 0; StartSpriteAffineAnimIfDifferent(sprite, 0); - return MovementAction_WalkDownStartAffine_Step1(eventObject, sprite); + return MovementAction_WalkDownStartAffine_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkDownStartAffine_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkDownStartAffine_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (an_walk_any_2(eventObject, sprite)) + if (an_walk_any_2(objectEvent, sprite)) { sprite->affineAnimPaused = TRUE; sprite->data[2] = 2; @@ -6508,19 +6508,19 @@ bool8 MovementAction_WalkDownStartAffine_Step1(struct EventObject *eventObject, return FALSE; } -bool8 MovementAction_WalkDownAffine_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_WalkDownAffine_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_WalkDownAffine_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkDownAffine_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8060ED8(eventObject, sprite, DIR_SOUTH); + sub_8060ED8(objectEvent, sprite, DIR_SOUTH); sprite->affineAnimPaused = 0; ChangeSpriteAffineAnimIfDifferent(sprite, 1); - return MovementAction_WalkDownAffine_Step1(eventObject, sprite); + return MovementAction_WalkDownAffine_Step1(objectEvent, sprite); } -bool8 MovementAction_WalkDownAffine_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_WalkDownAffine_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (an_walk_any_2(eventObject, sprite)) + if (an_walk_any_2(objectEvent, sprite)) { sprite->affineAnimPaused = TRUE; sprite->data[2] = 2; @@ -6529,388 +6529,388 @@ bool8 MovementAction_WalkDownAffine_Step1(struct EventObject *eventObject, struc return FALSE; } -void sub_806295C(struct EventObject *eventObject, struct Sprite *sprite, u8 direction) +void sub_806295C(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction) { - SetEventObjectDirection(eventObject, direction); - ShiftStillEventObjectCoords(eventObject); - sub_805FE64(eventObject, sprite, GetAcroWheeliePedalDirectionAnimNum(direction)); + SetObjectEventDirection(objectEvent, direction); + ShiftStillObjectEventCoords(objectEvent); + sub_805FE64(objectEvent, sprite, GetAcroWheeliePedalDirectionAnimNum(direction)); sprite->animPaused = 1; sprite->data[2] = 1; } -bool8 MovementAction_AcroWheelieFaceDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieFaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_806295C(eventObject, sprite, DIR_SOUTH); + sub_806295C(objectEvent, sprite, DIR_SOUTH); return TRUE; } -bool8 MovementAction_AcroWheelieFaceUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieFaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_806295C(eventObject, sprite, DIR_NORTH); + sub_806295C(objectEvent, sprite, DIR_NORTH); return TRUE; } -bool8 MovementAction_AcroWheelieFaceLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieFaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_806295C(eventObject, sprite, DIR_WEST); + sub_806295C(objectEvent, sprite, DIR_WEST); return TRUE; } -bool8 MovementAction_AcroWheelieFaceRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieFaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_806295C(eventObject, sprite, DIR_EAST); + sub_806295C(objectEvent, sprite, DIR_EAST); return TRUE; } -bool8 MovementAction_AcroPopWheelieDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_SOUTH, GetAcroWheelieDirectionAnimNum(DIR_SOUTH)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, GetAcroWheelieDirectionAnimNum(DIR_SOUTH)); return FALSE; } -bool8 MovementAction_AcroPopWheelieUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_NORTH, GetAcroWheelieDirectionAnimNum(DIR_NORTH)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_NORTH, GetAcroWheelieDirectionAnimNum(DIR_NORTH)); return FALSE; } -bool8 MovementAction_AcroPopWheelieLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_WEST, GetAcroWheelieDirectionAnimNum(DIR_WEST)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_WEST, GetAcroWheelieDirectionAnimNum(DIR_WEST)); return FALSE; } -bool8 MovementAction_AcroPopWheelieRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_EAST, GetAcroWheelieDirectionAnimNum(DIR_EAST)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_EAST, GetAcroWheelieDirectionAnimNum(DIR_EAST)); return FALSE; } -bool8 MovementAction_AcroEndWheelieFaceDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieFaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_SOUTH, GetAcroEndWheelieDirectionAnimNum(DIR_SOUTH)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, GetAcroEndWheelieDirectionAnimNum(DIR_SOUTH)); return FALSE; } -bool8 MovementAction_AcroEndWheelieFaceUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieFaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_NORTH, GetAcroEndWheelieDirectionAnimNum(DIR_NORTH)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_NORTH, GetAcroEndWheelieDirectionAnimNum(DIR_NORTH)); return FALSE; } -bool8 MovementAction_AcroEndWheelieFaceLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieFaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_WEST, GetAcroEndWheelieDirectionAnimNum(DIR_WEST)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_WEST, GetAcroEndWheelieDirectionAnimNum(DIR_WEST)); return FALSE; } -bool8 MovementAction_AcroEndWheelieFaceRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieFaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_EAST, GetAcroEndWheelieDirectionAnimNum(DIR_EAST)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_EAST, GetAcroEndWheelieDirectionAnimNum(DIR_EAST)); return FALSE; } -bool8 MovementAction_UnusedAcroActionDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_UnusedAcroActionDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_SOUTH, GetAcroUnusedActionDirectionAnimNum(DIR_SOUTH)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_SOUTH, GetAcroUnusedActionDirectionAnimNum(DIR_SOUTH)); return FALSE; } -bool8 MovementAction_UnusedAcroActionUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_UnusedAcroActionUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_NORTH, GetAcroUnusedActionDirectionAnimNum(DIR_NORTH)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_NORTH, GetAcroUnusedActionDirectionAnimNum(DIR_NORTH)); return FALSE; } -bool8 MovementAction_UnusedAcroActionLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_UnusedAcroActionLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_WEST, GetAcroUnusedActionDirectionAnimNum(DIR_WEST)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_WEST, GetAcroUnusedActionDirectionAnimNum(DIR_WEST)); return FALSE; } -bool8 MovementAction_UnusedAcroActionRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_UnusedAcroActionRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - StartSpriteAnimInDirection(eventObject, sprite, DIR_EAST, GetAcroUnusedActionDirectionAnimNum(DIR_EAST)); + StartSpriteAnimInDirection(objectEvent, sprite, DIR_EAST, GetAcroUnusedActionDirectionAnimNum(DIR_EAST)); return FALSE; } -void sub_8062B8C(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 a3, u8 a4) +void sub_8062B8C(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 a3, u8 a4) { - sub_806113C(eventObject, sprite, direction, a3, a4); + sub_806113C(objectEvent, sprite, direction, a3, a4); StartSpriteAnimIfDifferent(sprite, GetAcroWheelieDirectionAnimNum(direction)); - DoShadowFieldEffect(eventObject); + DoShadowFieldEffect(objectEvent); } -bool8 MovementAction_AcroWheelieHopFaceDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieHopFaceDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieHopFaceDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopFaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_SOUTH, 0, 1); - return MovementAction_AcroWheelieHopFaceDown_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_SOUTH, 0, 1); + return MovementAction_AcroWheelieHopFaceDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopFaceDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopFaceDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieHopFaceUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieHopFaceUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieHopFaceUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopFaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_NORTH, 0, 1); - return MovementAction_AcroWheelieHopFaceUp_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_NORTH, 0, 1); + return MovementAction_AcroWheelieHopFaceUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopFaceUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopFaceUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieHopFaceLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopFaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_WEST, 0, 1); - return MovementAction_AcroWheelieHopFaceLeft_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_WEST, 0, 1); + return MovementAction_AcroWheelieHopFaceLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopFaceLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieHopFaceRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieHopFaceRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieHopFaceRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopFaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_EAST, 0, 1); - return MovementAction_AcroWheelieHopFaceRight_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_EAST, 0, 1); + return MovementAction_AcroWheelieHopFaceRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopFaceRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopFaceRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieHopDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieHopDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieHopDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_SOUTH, 1, 1); - return MovementAction_AcroWheelieHopDown_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_SOUTH, 1, 1); + return MovementAction_AcroWheelieHopDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieHopUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieHopUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieHopUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_NORTH, 1, 1); - return MovementAction_AcroWheelieHopUp_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_NORTH, 1, 1); + return MovementAction_AcroWheelieHopUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieHopLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieHopLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieHopLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_WEST, 1, 1); - return MovementAction_AcroWheelieHopLeft_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_WEST, 1, 1); + return MovementAction_AcroWheelieHopLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieHopRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieHopRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieHopRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_EAST, 1, 1); - return MovementAction_AcroWheelieHopRight_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_EAST, 1, 1); + return MovementAction_AcroWheelieHopRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieHopRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieHopRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieJumpDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieJumpDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieJumpDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieJumpDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_SOUTH, 2, 0); - return MovementAction_AcroWheelieJumpDown_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_SOUTH, 2, 0); + return MovementAction_AcroWheelieJumpDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieJumpDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieJumpDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieJumpUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieJumpUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieJumpUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieJumpUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_NORTH, 2, 0); - return MovementAction_AcroWheelieJumpUp_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_NORTH, 2, 0); + return MovementAction_AcroWheelieJumpUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieJumpUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieJumpUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieJumpLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieJumpLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieJumpLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieJumpLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_WEST, 2, 0); - return MovementAction_AcroWheelieJumpLeft_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_WEST, 2, 0); + return MovementAction_AcroWheelieJumpLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieJumpLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieJumpLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieJumpRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieJumpRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieJumpRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieJumpRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8062B8C(eventObject, sprite, DIR_EAST, 2, 0); - return MovementAction_AcroWheelieJumpRight_Step1(eventObject, sprite); + sub_8062B8C(objectEvent, sprite, DIR_EAST, 2, 0); + return MovementAction_AcroWheelieJumpRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieJumpRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieJumpRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (sub_8061328(eventObject, sprite)) + if (sub_8061328(objectEvent, sprite)) { - eventObject->hasShadow = FALSE; + objectEvent->hasShadow = FALSE; sprite->data[2] = 2; return TRUE; } return FALSE; } -bool8 MovementAction_AcroWheelieInPlaceDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieInPlaceDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_SOUTH, GetAcroWheeliePedalDirectionAnimNum(DIR_SOUTH), 8); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_SOUTH, GetAcroWheeliePedalDirectionAnimNum(DIR_SOUTH), 8); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieInPlaceUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieInPlaceUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_NORTH, GetAcroWheeliePedalDirectionAnimNum(DIR_NORTH), 8); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_NORTH, GetAcroWheeliePedalDirectionAnimNum(DIR_NORTH), 8); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieInPlaceLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieInPlaceLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_WEST, GetAcroWheeliePedalDirectionAnimNum(DIR_WEST), 8); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_WEST, GetAcroWheeliePedalDirectionAnimNum(DIR_WEST), 8); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieInPlaceRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieInPlaceRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80616CC(eventObject, sprite, DIR_EAST, GetAcroWheeliePedalDirectionAnimNum(DIR_EAST), 8); - return MovementAction_WalkInPlace_Step1(eventObject, sprite); + sub_80616CC(objectEvent, sprite, DIR_EAST, GetAcroWheeliePedalDirectionAnimNum(DIR_EAST), 8); + return MovementAction_WalkInPlace_Step1(objectEvent, sprite); } -void sub_80630D0(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) +void sub_80630D0(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 speed) { - npc_apply_direction(eventObject, sprite, direction, speed); - StartSpriteAnim(sprite, GetAcroWheelieDirectionAnimNum(eventObject->facingDirection)); + npc_apply_direction(objectEvent, sprite, direction, speed); + StartSpriteAnim(sprite, GetAcroWheelieDirectionAnimNum(objectEvent->facingDirection)); SeekSpriteAnim(sprite, 0); } -bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroPopWheelieMoveDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieMoveDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80630D0(eventObject, sprite, DIR_SOUTH, 1); - return MovementAction_AcroPopWheelieMoveDown_Step1(eventObject, sprite); + sub_80630D0(objectEvent, sprite, DIR_SOUTH, 1); + return MovementAction_AcroPopWheelieMoveDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -6918,17 +6918,17 @@ bool8 MovementAction_AcroPopWheelieMoveDown_Step1(struct EventObject *eventObjec return FALSE; } -bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroPopWheelieMoveUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieMoveUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80630D0(eventObject, sprite, DIR_NORTH, 1); - return MovementAction_AcroPopWheelieMoveUp_Step1(eventObject, sprite); + sub_80630D0(objectEvent, sprite, DIR_NORTH, 1); + return MovementAction_AcroPopWheelieMoveUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -6936,17 +6936,17 @@ bool8 MovementAction_AcroPopWheelieMoveUp_Step1(struct EventObject *eventObject, return FALSE; } -bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroPopWheelieMoveLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieMoveLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80630D0(eventObject, sprite, DIR_WEST, 1); - return MovementAction_AcroPopWheelieMoveLeft_Step1(eventObject, sprite); + sub_80630D0(objectEvent, sprite, DIR_WEST, 1); + return MovementAction_AcroPopWheelieMoveLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -6954,17 +6954,17 @@ bool8 MovementAction_AcroPopWheelieMoveLeft_Step1(struct EventObject *eventObjec return FALSE; } -bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroPopWheelieMoveRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieMoveRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_80630D0(eventObject, sprite, DIR_EAST, 1); - return MovementAction_AcroPopWheelieMoveRight_Step1(eventObject, sprite); + sub_80630D0(objectEvent, sprite, DIR_EAST, 1); + return MovementAction_AcroPopWheelieMoveRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -6972,23 +6972,23 @@ bool8 MovementAction_AcroPopWheelieMoveRight_Step1(struct EventObject *eventObje return FALSE; } -void sub_8063208(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) +void sub_8063208(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 speed) { - npc_apply_direction(eventObject, sprite, direction, speed); - sub_805FE28(eventObject, sprite, GetAcroWheeliePedalDirectionAnimNum(eventObject->facingDirection)); + npc_apply_direction(objectEvent, sprite, direction, speed); + sub_805FE28(objectEvent, sprite, GetAcroWheeliePedalDirectionAnimNum(objectEvent->facingDirection)); } -bool8 MovementAction_AcroWheelieMoveDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieMoveDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieMoveDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieMoveDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8063208(eventObject, sprite, DIR_SOUTH, 1); - return MovementAction_AcroWheelieMoveDown_Step1(eventObject, sprite); + sub_8063208(objectEvent, sprite, DIR_SOUTH, 1); + return MovementAction_AcroWheelieMoveDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieMoveDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieMoveDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -6996,17 +6996,17 @@ bool8 MovementAction_AcroWheelieMoveDown_Step1(struct EventObject *eventObject, return FALSE; } -bool8 MovementAction_AcroWheelieMoveUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieMoveUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieMoveUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieMoveUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8063208(eventObject, sprite, DIR_NORTH, 1); - return MovementAction_AcroWheelieMoveUp_Step1(eventObject, sprite); + sub_8063208(objectEvent, sprite, DIR_NORTH, 1); + return MovementAction_AcroWheelieMoveUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieMoveUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -7014,17 +7014,17 @@ bool8 MovementAction_AcroWheelieMoveUp_Step1(struct EventObject *eventObject, st return FALSE; } -bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieMoveLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieMoveLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8063208(eventObject, sprite, DIR_WEST, 1); - return MovementAction_AcroWheelieMoveLeft_Step1(eventObject, sprite); + sub_8063208(objectEvent, sprite, DIR_WEST, 1); + return MovementAction_AcroWheelieMoveLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -7032,17 +7032,17 @@ bool8 MovementAction_AcroWheelieMoveLeft_Step1(struct EventObject *eventObject, return FALSE; } -bool8 MovementAction_AcroWheelieMoveRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroWheelieMoveRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroWheelieMoveRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieMoveRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8063208(eventObject, sprite, DIR_EAST, 1); - return MovementAction_AcroWheelieMoveRight_Step1(eventObject, sprite); + sub_8063208(objectEvent, sprite, DIR_EAST, 1); + return MovementAction_AcroWheelieMoveRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroWheelieMoveRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroWheelieMoveRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -7050,24 +7050,24 @@ bool8 MovementAction_AcroWheelieMoveRight_Step1(struct EventObject *eventObject, return FALSE; } -void sub_8063338(struct EventObject *eventObject, struct Sprite *sprite, u8 direction, u8 speed) +void sub_8063338(struct ObjectEvent *objectEvent, struct Sprite *sprite, u8 direction, u8 speed) { - npc_apply_direction(eventObject, sprite, direction, speed); - StartSpriteAnim(sprite, GetAcroEndWheelieDirectionAnimNum(eventObject->facingDirection)); + npc_apply_direction(objectEvent, sprite, direction, speed); + StartSpriteAnim(sprite, GetAcroEndWheelieDirectionAnimNum(objectEvent->facingDirection)); SeekSpriteAnim(sprite, 0); } -bool8 MovementAction_AcroEndWheelieMoveDown_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroEndWheelieMoveDown_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroEndWheelieMoveDown_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieMoveDown_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8063338(eventObject, sprite, DIR_SOUTH, 1); - return MovementAction_AcroEndWheelieMoveDown_Step1(eventObject, sprite); + sub_8063338(objectEvent, sprite, DIR_SOUTH, 1); + return MovementAction_AcroEndWheelieMoveDown_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroEndWheelieMoveDown_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieMoveDown_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -7075,17 +7075,17 @@ bool8 MovementAction_AcroEndWheelieMoveDown_Step1(struct EventObject *eventObjec return FALSE; } -bool8 MovementAction_AcroEndWheelieMoveUp_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroEndWheelieMoveUp_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroEndWheelieMoveUp_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieMoveUp_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8063338(eventObject, sprite, DIR_NORTH, 1); - return MovementAction_AcroEndWheelieMoveUp_Step1(eventObject, sprite); + sub_8063338(objectEvent, sprite, DIR_NORTH, 1); + return MovementAction_AcroEndWheelieMoveUp_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroEndWheelieMoveUp_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieMoveUp_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -7093,17 +7093,17 @@ bool8 MovementAction_AcroEndWheelieMoveUp_Step1(struct EventObject *eventObject, return FALSE; } -bool8 MovementAction_AcroEndWheelieMoveLeft_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroEndWheelieMoveLeft_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroEndWheelieMoveLeft_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieMoveLeft_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8063338(eventObject, sprite, DIR_WEST, 1); - return MovementAction_AcroEndWheelieMoveLeft_Step1(eventObject, sprite); + sub_8063338(objectEvent, sprite, DIR_WEST, 1); + return MovementAction_AcroEndWheelieMoveLeft_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroEndWheelieMoveLeft_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieMoveLeft_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -7111,17 +7111,17 @@ bool8 MovementAction_AcroEndWheelieMoveLeft_Step1(struct EventObject *eventObjec return FALSE; } -bool8 MovementAction_AcroEndWheelieMoveRight_Step1(struct EventObject *, struct Sprite *); +bool8 MovementAction_AcroEndWheelieMoveRight_Step1(struct ObjectEvent *, struct Sprite *); -bool8 MovementAction_AcroEndWheelieMoveRight_Step0(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieMoveRight_Step0(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - sub_8063338(eventObject, sprite, DIR_EAST, 1); - return MovementAction_AcroEndWheelieMoveRight_Step1(eventObject, sprite); + sub_8063338(objectEvent, sprite, DIR_EAST, 1); + return MovementAction_AcroEndWheelieMoveRight_Step1(objectEvent, sprite); } -bool8 MovementAction_AcroEndWheelieMoveRight_Step1(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_AcroEndWheelieMoveRight_Step1(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (npc_obj_ministep_stop_on_arrival(eventObject, sprite)) + if (npc_obj_ministep_stop_on_arrival(objectEvent, sprite)) { sprite->data[2] = 2; return TRUE; @@ -7129,46 +7129,46 @@ bool8 MovementAction_AcroEndWheelieMoveRight_Step1(struct EventObject *eventObje return FALSE; } -bool8 MovementAction_Finish(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_Finish(struct ObjectEvent *objectEvent, struct Sprite *sprite) { return TRUE; } -bool8 MovementAction_PauseSpriteAnim(struct EventObject *eventObject, struct Sprite *sprite) +bool8 MovementAction_PauseSpriteAnim(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->animPaused = TRUE; return TRUE; } -static void UpdateEventObjectSpriteAnimPause(struct EventObject *eventObject, struct Sprite *sprite) +static void UpdateObjectEventSpriteAnimPause(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (eventObject->disableAnim) + if (objectEvent->disableAnim) sprite->animPaused = TRUE; } -static void TryEnableEventObjectAnim(struct EventObject *eventObject, struct Sprite *sprite) +static void TryEnableObjectEventAnim(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - if (eventObject->enableAnim) + if (objectEvent->enableAnim) { sprite->animPaused = FALSE; - eventObject->disableAnim = FALSE; - eventObject->enableAnim = FALSE; + objectEvent->disableAnim = FALSE; + objectEvent->enableAnim = FALSE; } } -static void UpdateEventObjectVisibility(struct EventObject *eventObject, struct Sprite *sprite) +static void UpdateObjectEventVisibility(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - UpdateEventObjectIsOffscreen(eventObject, sprite); - UpdateEventObjSpriteVisibility(eventObject, sprite); + UpdateObjectEventIsOffscreen(objectEvent, sprite); + UpdateObjEventSpriteVisibility(objectEvent, sprite); } -static void UpdateEventObjectIsOffscreen(struct EventObject *eventObject, struct Sprite *sprite) +static void UpdateObjectEventIsOffscreen(struct ObjectEvent *objectEvent, struct Sprite *sprite) { u16 x, y; s16 x2, y2; - const struct EventObjectGraphicsInfo *graphicsInfo; - eventObject->offScreen = FALSE; - graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + const struct ObjectEventGraphicsInfo *graphicsInfo; + objectEvent->offScreen = FALSE; + graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId); if (sprite->coordOffsetEnabled) { x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX + gSpriteCoordOffsetX; @@ -7184,221 +7184,221 @@ static void UpdateEventObjectIsOffscreen(struct EventObject *eventObject, struct y2 = graphicsInfo->height + (s16)y; if ((s16)x >= 0x100 || x2 < -0x10) { - eventObject->offScreen = TRUE; + objectEvent->offScreen = TRUE; } if ((s16)y >= 0xB0 || y2 < -0x10) { - eventObject->offScreen = TRUE; + objectEvent->offScreen = TRUE; } } -static void UpdateEventObjSpriteVisibility(struct EventObject *eventObject, struct Sprite *sprite) +static void UpdateObjEventSpriteVisibility(struct ObjectEvent *objectEvent, struct Sprite *sprite) { sprite->invisible = FALSE; - if (eventObject->invisible || eventObject->offScreen) + if (objectEvent->invisible || objectEvent->offScreen) { sprite->invisible = TRUE; } } -static void GetAllGroundEffectFlags_OnSpawn(struct EventObject *eventObj, u32 *flags) +static void GetAllGroundEffectFlags_OnSpawn(struct ObjectEvent *objEvent, u32 *flags) { - EventObjectUpdateMetatileBehaviors(eventObj); - GetGroundEffectFlags_Reflection(eventObj, flags); - GetGroundEffectFlags_TallGrassOnSpawn(eventObj, flags); - GetGroundEffectFlags_LongGrassOnSpawn(eventObj, flags); - GetGroundEffectFlags_SandPile(eventObj, flags); - GetGroundEffectFlags_ShallowFlowingWater(eventObj, flags); - GetGroundEffectFlags_ShortGrass(eventObj, flags); - GetGroundEffectFlags_HotSprings(eventObj, flags); + ObjectEventUpdateMetatileBehaviors(objEvent); + GetGroundEffectFlags_Reflection(objEvent, flags); + GetGroundEffectFlags_TallGrassOnSpawn(objEvent, flags); + GetGroundEffectFlags_LongGrassOnSpawn(objEvent, flags); + GetGroundEffectFlags_SandPile(objEvent, flags); + GetGroundEffectFlags_ShallowFlowingWater(objEvent, flags); + GetGroundEffectFlags_ShortGrass(objEvent, flags); + GetGroundEffectFlags_HotSprings(objEvent, flags); } -static void GetAllGroundEffectFlags_OnBeginStep(struct EventObject *eventObj, u32 *flags) +static void GetAllGroundEffectFlags_OnBeginStep(struct ObjectEvent *objEvent, u32 *flags) { - EventObjectUpdateMetatileBehaviors(eventObj); - GetGroundEffectFlags_Reflection(eventObj, flags); - GetGroundEffectFlags_TallGrassOnBeginStep(eventObj, flags); - GetGroundEffectFlags_LongGrassOnBeginStep(eventObj, flags); - GetGroundEffectFlags_Tracks(eventObj, flags); - GetGroundEffectFlags_SandPile(eventObj, flags); - GetGroundEffectFlags_ShallowFlowingWater(eventObj, flags); - GetGroundEffectFlags_Puddle(eventObj, flags); - GetGroundEffectFlags_ShortGrass(eventObj, flags); - GetGroundEffectFlags_HotSprings(eventObj, flags); + ObjectEventUpdateMetatileBehaviors(objEvent); + GetGroundEffectFlags_Reflection(objEvent, flags); + GetGroundEffectFlags_TallGrassOnBeginStep(objEvent, flags); + GetGroundEffectFlags_LongGrassOnBeginStep(objEvent, flags); + GetGroundEffectFlags_Tracks(objEvent, flags); + GetGroundEffectFlags_SandPile(objEvent, flags); + GetGroundEffectFlags_ShallowFlowingWater(objEvent, flags); + GetGroundEffectFlags_Puddle(objEvent, flags); + GetGroundEffectFlags_ShortGrass(objEvent, flags); + GetGroundEffectFlags_HotSprings(objEvent, flags); } -static void GetAllGroundEffectFlags_OnFinishStep(struct EventObject *eventObj, u32 *flags) +static void GetAllGroundEffectFlags_OnFinishStep(struct ObjectEvent *objEvent, u32 *flags) { - EventObjectUpdateMetatileBehaviors(eventObj); - GetGroundEffectFlags_ShallowFlowingWater(eventObj, flags); - GetGroundEffectFlags_SandPile(eventObj, flags); - GetGroundEffectFlags_Puddle(eventObj, flags); - GetGroundEffectFlags_Ripple(eventObj, flags); - GetGroundEffectFlags_ShortGrass(eventObj, flags); - GetGroundEffectFlags_HotSprings(eventObj, flags); - GetGroundEffectFlags_Seaweed(eventObj, flags); - GetGroundEffectFlags_JumpLanding(eventObj, flags); + ObjectEventUpdateMetatileBehaviors(objEvent); + GetGroundEffectFlags_ShallowFlowingWater(objEvent, flags); + GetGroundEffectFlags_SandPile(objEvent, flags); + GetGroundEffectFlags_Puddle(objEvent, flags); + GetGroundEffectFlags_Ripple(objEvent, flags); + GetGroundEffectFlags_ShortGrass(objEvent, flags); + GetGroundEffectFlags_HotSprings(objEvent, flags); + GetGroundEffectFlags_Seaweed(objEvent, flags); + GetGroundEffectFlags_JumpLanding(objEvent, flags); } -static void EventObjectUpdateMetatileBehaviors(struct EventObject *eventObj) +static void ObjectEventUpdateMetatileBehaviors(struct ObjectEvent *objEvent) { - eventObj->previousMetatileBehavior = MapGridGetMetatileBehaviorAt(eventObj->previousCoords.x, eventObj->previousCoords.y); - eventObj->currentMetatileBehavior = MapGridGetMetatileBehaviorAt(eventObj->currentCoords.x, eventObj->currentCoords.y); + objEvent->previousMetatileBehavior = MapGridGetMetatileBehaviorAt(objEvent->previousCoords.x, objEvent->previousCoords.y); + objEvent->currentMetatileBehavior = MapGridGetMetatileBehaviorAt(objEvent->currentCoords.x, objEvent->currentCoords.y); } -static void GetGroundEffectFlags_Reflection(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Reflection(struct ObjectEvent *objEvent, u32 *flags) { u32 reflectionFlags[2] = { GROUND_EFFECT_FLAG_REFLECTION, GROUND_EFFECT_FLAG_ICE_REFLECTION }; - u8 type = EventObjectCheckForReflectiveSurface(eventObj); + u8 type = ObjectEventCheckForReflectiveSurface(objEvent); if (type) { - if (!eventObj->hasReflection) + if (!objEvent->hasReflection) { - eventObj->hasReflection = 0; - eventObj->hasReflection = 1; + objEvent->hasReflection = 0; + objEvent->hasReflection = 1; *flags |= reflectionFlags[type - 1]; } } else { - eventObj->hasReflection = 0; + objEvent->hasReflection = 0; } } -static void GetGroundEffectFlags_TallGrassOnSpawn(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_TallGrassOnSpawn(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsTallGrass(eventObj->currentMetatileBehavior)) + if (MetatileBehavior_IsTallGrass(objEvent->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_TALL_GRASS_ON_SPAWN; } -static void GetGroundEffectFlags_TallGrassOnBeginStep(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_TallGrassOnBeginStep(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsTallGrass(eventObj->currentMetatileBehavior)) + if (MetatileBehavior_IsTallGrass(objEvent->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_TALL_GRASS_ON_MOVE; } -static void GetGroundEffectFlags_LongGrassOnSpawn(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_LongGrassOnSpawn(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsLongGrass(eventObj->currentMetatileBehavior)) + if (MetatileBehavior_IsLongGrass(objEvent->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_LONG_GRASS_ON_SPAWN; } -static void GetGroundEffectFlags_LongGrassOnBeginStep(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_LongGrassOnBeginStep(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsLongGrass(eventObj->currentMetatileBehavior)) + if (MetatileBehavior_IsLongGrass(objEvent->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_LONG_GRASS_ON_MOVE; } -static void GetGroundEffectFlags_Tracks(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Tracks(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsDeepSand(eventObj->previousMetatileBehavior)) + if (MetatileBehavior_IsDeepSand(objEvent->previousMetatileBehavior)) { *flags |= GROUND_EFFECT_FLAG_DEEP_SAND; } - else if (MetatileBehavior_IsSandOrDeepSand(eventObj->previousMetatileBehavior) - || MetatileBehavior_IsFootprints(eventObj->previousMetatileBehavior)) + else if (MetatileBehavior_IsSandOrDeepSand(objEvent->previousMetatileBehavior) + || MetatileBehavior_IsFootprints(objEvent->previousMetatileBehavior)) { *flags |= GROUND_EFFECT_FLAG_SAND; } } -static void GetGroundEffectFlags_SandPile(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_SandPile(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsDeepSand(eventObj->currentMetatileBehavior) - && MetatileBehavior_IsDeepSand(eventObj->previousMetatileBehavior)) + if (MetatileBehavior_IsDeepSand(objEvent->currentMetatileBehavior) + && MetatileBehavior_IsDeepSand(objEvent->previousMetatileBehavior)) { - if (!eventObj->inSandPile) + if (!objEvent->inSandPile) { - eventObj->inSandPile = 0; - eventObj->inSandPile = 1; + objEvent->inSandPile = 0; + objEvent->inSandPile = 1; *flags |= GROUND_EFFECT_FLAG_SAND_PILE; } } else { - eventObj->inSandPile = 0; + objEvent->inSandPile = 0; } } -static void GetGroundEffectFlags_ShallowFlowingWater(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_ShallowFlowingWater(struct ObjectEvent *objEvent, u32 *flags) { - if ((MetatileBehavior_IsShallowFlowingWater(eventObj->currentMetatileBehavior) - && MetatileBehavior_IsShallowFlowingWater(eventObj->previousMetatileBehavior)) - || (MetatileBehavior_IsPacifidlogLog(eventObj->currentMetatileBehavior) - && MetatileBehavior_IsPacifidlogLog(eventObj->previousMetatileBehavior))) + if ((MetatileBehavior_IsShallowFlowingWater(objEvent->currentMetatileBehavior) + && MetatileBehavior_IsShallowFlowingWater(objEvent->previousMetatileBehavior)) + || (MetatileBehavior_IsPacifidlogLog(objEvent->currentMetatileBehavior) + && MetatileBehavior_IsPacifidlogLog(objEvent->previousMetatileBehavior))) { - if (!eventObj->inShallowFlowingWater) + if (!objEvent->inShallowFlowingWater) { - eventObj->inShallowFlowingWater = 0; - eventObj->inShallowFlowingWater = 1; + objEvent->inShallowFlowingWater = 0; + objEvent->inShallowFlowingWater = 1; *flags |= GROUND_EFFECT_FLAG_SHALLOW_FLOWING_WATER; } } else { - eventObj->inShallowFlowingWater = 0; + objEvent->inShallowFlowingWater = 0; } } -static void GetGroundEffectFlags_Puddle(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Puddle(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsPuddle(eventObj->currentMetatileBehavior) - && MetatileBehavior_IsPuddle(eventObj->previousMetatileBehavior)) + if (MetatileBehavior_IsPuddle(objEvent->currentMetatileBehavior) + && MetatileBehavior_IsPuddle(objEvent->previousMetatileBehavior)) { *flags |= GROUND_EFFECT_FLAG_PUDDLE; } } -static void GetGroundEffectFlags_Ripple(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Ripple(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_HasRipples(eventObj->currentMetatileBehavior)) + if (MetatileBehavior_HasRipples(objEvent->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_RIPPLES; } -static void GetGroundEffectFlags_ShortGrass(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_ShortGrass(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsShortGrass(eventObj->currentMetatileBehavior) - && MetatileBehavior_IsShortGrass(eventObj->previousMetatileBehavior)) + if (MetatileBehavior_IsShortGrass(objEvent->currentMetatileBehavior) + && MetatileBehavior_IsShortGrass(objEvent->previousMetatileBehavior)) { - if (!eventObj->inShortGrass) + if (!objEvent->inShortGrass) { - eventObj->inShortGrass = 0; - eventObj->inShortGrass = 1; + objEvent->inShortGrass = 0; + objEvent->inShortGrass = 1; *flags |= GROUND_EFFECT_FLAG_SHORT_GRASS; } } else { - eventObj->inShortGrass = 0; + objEvent->inShortGrass = 0; } } -static void GetGroundEffectFlags_HotSprings(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_HotSprings(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsHotSprings(eventObj->currentMetatileBehavior) - && MetatileBehavior_IsHotSprings(eventObj->previousMetatileBehavior)) + if (MetatileBehavior_IsHotSprings(objEvent->currentMetatileBehavior) + && MetatileBehavior_IsHotSprings(objEvent->previousMetatileBehavior)) { - if (!eventObj->inHotSprings) + if (!objEvent->inHotSprings) { - eventObj->inHotSprings = 0; - eventObj->inHotSprings = 1; + objEvent->inHotSprings = 0; + objEvent->inHotSprings = 1; *flags |= GROUND_EFFECT_FLAG_HOT_SPRINGS; } } else { - eventObj->inHotSprings = 0; + objEvent->inHotSprings = 0; } } -static void GetGroundEffectFlags_Seaweed(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_Seaweed(struct ObjectEvent *objEvent, u32 *flags) { - if (MetatileBehavior_IsSeaweed(eventObj->currentMetatileBehavior)) + if (MetatileBehavior_IsSeaweed(objEvent->currentMetatileBehavior)) *flags |= GROUND_EFFECT_FLAG_SEAWEED; } -static void GetGroundEffectFlags_JumpLanding(struct EventObject *eventObj, u32 *flags) +static void GetGroundEffectFlags_JumpLanding(struct ObjectEvent *objEvent, u32 *flags) { typedef bool8 (*MetatileFunc)(u8); @@ -7420,13 +7420,13 @@ static void GetGroundEffectFlags_JumpLanding(struct EventObject *eventObj, u32 * GROUND_EFFECT_FLAG_LAND_ON_NORMAL_GROUND, }; - if (eventObj->landingJump && !eventObj->disableJumpLandingGroundEffect) + if (objEvent->landingJump && !objEvent->disableJumpLandingGroundEffect) { u8 i; for (i = 0; i < ARRAY_COUNT(metatileFuncs); i++) { - if (metatileFuncs[i](eventObj->currentMetatileBehavior)) + if (metatileFuncs[i](objEvent->currentMetatileBehavior)) { *flags |= jumpLandingFlags[i]; return; @@ -7435,9 +7435,9 @@ static void GetGroundEffectFlags_JumpLanding(struct EventObject *eventObj, u32 * } } -static u8 EventObjectCheckForReflectiveSurface(struct EventObject *eventObj) +static u8 ObjectEventCheckForReflectiveSurface(struct ObjectEvent *objEvent) { - const struct EventObjectGraphicsInfo *info = GetEventObjectGraphicsInfo(eventObj->graphicsId); + const struct ObjectEventGraphicsInfo *info = GetObjectEventGraphicsInfo(objEvent->graphicsId); // ceil div by tile width? s16 width = (info->width + 8) >> 4; @@ -7456,14 +7456,14 @@ static u8 EventObjectCheckForReflectiveSurface(struct EventObject *eventObj) for (i = 0, one = 1; i < height; i++) { - RETURN_REFLECTION_TYPE_AT(eventObj->currentCoords.x, eventObj->currentCoords.y + one + i) - RETURN_REFLECTION_TYPE_AT(eventObj->previousCoords.x, eventObj->previousCoords.y + one + i) + RETURN_REFLECTION_TYPE_AT(objEvent->currentCoords.x, objEvent->currentCoords.y + one + i) + RETURN_REFLECTION_TYPE_AT(objEvent->previousCoords.x, objEvent->previousCoords.y + one + i) for (j = 1; j < width; j++) { - RETURN_REFLECTION_TYPE_AT(eventObj->currentCoords.x + j, eventObj->currentCoords.y + one + i) - RETURN_REFLECTION_TYPE_AT(eventObj->currentCoords.x - j, eventObj->currentCoords.y + one + i) - RETURN_REFLECTION_TYPE_AT(eventObj->previousCoords.x + j, eventObj->previousCoords.y + one + i) - RETURN_REFLECTION_TYPE_AT(eventObj->previousCoords.x - j, eventObj->previousCoords.y + one + i) + RETURN_REFLECTION_TYPE_AT(objEvent->currentCoords.x + j, objEvent->currentCoords.y + one + i) + RETURN_REFLECTION_TYPE_AT(objEvent->currentCoords.x - j, objEvent->currentCoords.y + one + i) + RETURN_REFLECTION_TYPE_AT(objEvent->previousCoords.x + j, objEvent->previousCoords.y + one + i) + RETURN_REFLECTION_TYPE_AT(objEvent->previousCoords.x - j, objEvent->previousCoords.y + one + i) } } return 0; @@ -7507,20 +7507,20 @@ u8 GetLedgeJumpDirection(s16 x, s16 y, u8 z) return 0; } -static void SetEventObjectSpriteOamTableForLongGrass(struct EventObject *eventObj, struct Sprite *sprite) +static void SetObjectEventSpriteOamTableForLongGrass(struct ObjectEvent *objEvent, struct Sprite *sprite) { - if (eventObj->disableCoveringGroundEffects) + if (objEvent->disableCoveringGroundEffects) return; - if (!MetatileBehavior_IsLongGrass(eventObj->currentMetatileBehavior)) + if (!MetatileBehavior_IsLongGrass(objEvent->currentMetatileBehavior)) return; - if (!MetatileBehavior_IsLongGrass(eventObj->previousMetatileBehavior)) + if (!MetatileBehavior_IsLongGrass(objEvent->previousMetatileBehavior)) return; sprite->subspriteTableNum = 4; - if (ZCoordToPriority(eventObj->previousElevation) == 1) + if (ZCoordToPriority(objEvent->previousElevation) == 1) sprite->subspriteTableNum = 5; } @@ -7546,54 +7546,54 @@ static const u8 sUnknown_08376050[] = { 0x73, 0x73, 0x53, 0x73, 0x53, 0x73, 0x53, 0x73, 0x53, 0x73, 0x53, 0x73, 0x53, 0x00, 0x00, 0x73 }; -// Each byte corresponds to a sprite priority for an event object. -// This is directly the inverse of gEventObjectPriorities_08376070. -static const u8 sEventObjectPriorities_08376060[] = { +// Each byte corresponds to a sprite priority for an object event. +// This is directly the inverse of gObjectEventPriorities_08376070. +static const u8 sObjectEventPriorities_08376060[] = { 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, 0, 2 }; -// Each byte corresponds to a sprite priority for an event object. -// This is the inverse of gEventObjectPriorities_08376060. +// Each byte corresponds to a sprite priority for an object event. +// This is the inverse of gObjectEventPriorities_08376060. // 1 = Above player sprite // 2 = Below player sprite -static const u8 sEventObjectPriorities_08376070[] = { +static const u8 sObjectEventPriorities_08376070[] = { 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 1, }; -void UpdateEventObjectZCoordAndPriority(struct EventObject *eventObj, struct Sprite *sprite) +void UpdateObjectEventZCoordAndPriority(struct ObjectEvent *objEvent, struct Sprite *sprite) { - if (eventObj->fixedPriority) + if (objEvent->fixedPriority) return; - EventObjectUpdateZCoord(eventObj); + ObjectEventUpdateZCoord(objEvent); - sprite->subspriteTableNum = sEventObjectPriorities_08376070[eventObj->previousElevation]; - sprite->oam.priority = sEventObjectPriorities_08376060[eventObj->previousElevation]; + sprite->subspriteTableNum = sObjectEventPriorities_08376070[objEvent->previousElevation]; + sprite->oam.priority = sObjectEventPriorities_08376060[objEvent->previousElevation]; } static void InitObjectPriorityByZCoord(struct Sprite *sprite, u8 z) { - sprite->subspriteTableNum = sEventObjectPriorities_08376070[z]; - sprite->oam.priority = sEventObjectPriorities_08376060[z]; + sprite->subspriteTableNum = sObjectEventPriorities_08376070[z]; + sprite->oam.priority = sObjectEventPriorities_08376060[z]; } u8 ZCoordToPriority(u8 z) { - return sEventObjectPriorities_08376060[z]; + return sObjectEventPriorities_08376060[z]; } -void EventObjectUpdateZCoord(struct EventObject *eventObj) +void ObjectEventUpdateZCoord(struct ObjectEvent *objEvent) { - u8 z = MapGridGetZCoordAt(eventObj->currentCoords.x, eventObj->currentCoords.y); - u8 z2 = MapGridGetZCoordAt(eventObj->previousCoords.x, eventObj->previousCoords.y); + u8 z = MapGridGetZCoordAt(objEvent->currentCoords.x, objEvent->currentCoords.y); + u8 z2 = MapGridGetZCoordAt(objEvent->previousCoords.x, objEvent->previousCoords.y); if (z == 0xF || z2 == 0xF) return; - eventObj->currentElevation = z; + objEvent->currentElevation = z; if (z != 0 && z != 0xF) - eventObj->previousElevation = z; + objEvent->previousElevation = z; } void SetObjectSubpriorityByZCoord(u8 a, struct Sprite *sprite, u8 b) @@ -7606,12 +7606,12 @@ void SetObjectSubpriorityByZCoord(u8 a, struct Sprite *sprite, u8 b) sprite->subpriority = tmp3 + sUnknown_08376050[a] + b; } -static void EventObjectUpdateSubpriority(struct EventObject *eventObj, struct Sprite *sprite) +static void ObjectEventUpdateSubpriority(struct ObjectEvent *objEvent, struct Sprite *sprite) { - if (eventObj->fixedPriority) + if (objEvent->fixedPriority) return; - SetObjectSubpriorityByZCoord(eventObj->previousElevation, sprite, 1); + SetObjectSubpriorityByZCoord(objEvent->previousElevation, sprite, 1); } bool8 AreZCoordsCompatible(u8 a, u8 b) @@ -7625,94 +7625,94 @@ bool8 AreZCoordsCompatible(u8 a, u8 b) return TRUE; } -void GroundEffect_SpawnOnTallGrass(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_SpawnOnTallGrass(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = 2; - gFieldEffectArguments[4] = eventObj->localId << 8 | eventObj->mapNum; - gFieldEffectArguments[5] = eventObj->mapGroup; + gFieldEffectArguments[4] = objEvent->localId << 8 | objEvent->mapNum; + gFieldEffectArguments[5] = objEvent->mapGroup; gFieldEffectArguments[6] = (u8)gSaveBlock1.location.mapNum << 8 | (u8)gSaveBlock1.location.mapGroup; gFieldEffectArguments[7] = 1; FieldEffectStart(FLDEFF_TALL_GRASS); } -void GroundEffect_MoveOnTallGrass(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_MoveOnTallGrass(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = 2; - gFieldEffectArguments[4] = eventObj->localId << 8 | eventObj->mapNum; - gFieldEffectArguments[5] = eventObj->mapGroup; + gFieldEffectArguments[4] = objEvent->localId << 8 | objEvent->mapNum; + gFieldEffectArguments[5] = objEvent->mapGroup; gFieldEffectArguments[6] = (u8)gSaveBlock1.location.mapNum << 8 | (u8)gSaveBlock1.location.mapGroup; gFieldEffectArguments[7] = 0; FieldEffectStart(FLDEFF_TALL_GRASS); } -void GroundEffect_SpawnOnLongGrass(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_SpawnOnLongGrass(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = 2; - gFieldEffectArguments[4] = eventObj->localId << 8 | eventObj->mapNum; - gFieldEffectArguments[5] = eventObj->mapGroup; + gFieldEffectArguments[4] = objEvent->localId << 8 | objEvent->mapNum; + gFieldEffectArguments[5] = objEvent->mapGroup; gFieldEffectArguments[6] = (u8)gSaveBlock1.location.mapNum << 8 | (u8)gSaveBlock1.location.mapGroup; gFieldEffectArguments[7] = 1; FieldEffectStart(FLDEFF_LONG_GRASS); } -void GroundEffect_MoveOnLongGrass(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_MoveOnLongGrass(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = 2; - gFieldEffectArguments[4] = (eventObj->localId << 8) | eventObj->mapNum; - gFieldEffectArguments[5] = eventObj->mapGroup; + gFieldEffectArguments[4] = (objEvent->localId << 8) | objEvent->mapNum; + gFieldEffectArguments[5] = objEvent->mapGroup; gFieldEffectArguments[6] = (u8)gSaveBlock1.location.mapNum << 8 | (u8)gSaveBlock1.location.mapGroup; gFieldEffectArguments[7] = 0; FieldEffectStart(FLDEFF_LONG_GRASS); } -void GroundEffect_WaterReflection(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_WaterReflection(struct ObjectEvent *objEvent, struct Sprite *sprite) { - InitObjectReflectionSprite(eventObj, sprite, 0); + InitObjectReflectionSprite(objEvent, sprite, 0); } -void GroundEffect_IceReflection(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_IceReflection(struct ObjectEvent *objEvent, struct Sprite *sprite) { - InitObjectReflectionSprite(eventObj, sprite, 1); + InitObjectReflectionSprite(objEvent, sprite, 1); } -void GroundEffect_FlowingWater(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_FlowingWater(struct ObjectEvent *objEvent, struct Sprite *sprite) { - StartFieldEffectForEventObject(FLDEFF_FEET_IN_FLOWING_WATER, eventObj); + StartFieldEffectForObjectEvent(FLDEFF_FEET_IN_FLOWING_WATER, objEvent); } -static void (*const sGroundEffectTracksFuncs[])(struct EventObject *eventObj, struct Sprite *sprite, u8 a) = { +static void (*const sGroundEffectTracksFuncs[])(struct ObjectEvent *objEvent, struct Sprite *sprite, u8 a) = { nullsub, DoTracksGroundEffect_Footprints, DoTracksGroundEffect_BikeTireTracks, }; -void GroundEffect_SandTracks(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_SandTracks(struct ObjectEvent *objEvent, struct Sprite *sprite) { - const struct EventObjectGraphicsInfo *info = GetEventObjectGraphicsInfo(eventObj->graphicsId); - sGroundEffectTracksFuncs[info->tracks](eventObj, sprite, 0); + const struct ObjectEventGraphicsInfo *info = GetObjectEventGraphicsInfo(objEvent->graphicsId); + sGroundEffectTracksFuncs[info->tracks](objEvent, sprite, 0); } -void GroundEffect_DeepSandTracks(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_DeepSandTracks(struct ObjectEvent *objEvent, struct Sprite *sprite) { - const struct EventObjectGraphicsInfo *info = GetEventObjectGraphicsInfo(eventObj->graphicsId); - sGroundEffectTracksFuncs[info->tracks](eventObj, sprite, 1); + const struct ObjectEventGraphicsInfo *info = GetObjectEventGraphicsInfo(objEvent->graphicsId); + sGroundEffectTracksFuncs[info->tracks](objEvent, sprite, 1); } -static void nullsub(struct EventObject *eventObj, struct Sprite *sprite, u8 a) +static void nullsub(struct ObjectEvent *objEvent, struct Sprite *sprite, u8 a) { } -static void DoTracksGroundEffect_Footprints(struct EventObject *eventObj, struct Sprite *sprite, u8 a) +static void DoTracksGroundEffect_Footprints(struct ObjectEvent *objEvent, struct Sprite *sprite, u8 a) { // First half-word is a Field Effect script id. (gFieldEffectScriptPointers) u16 sandFootprints_FieldEffectData[2] = { @@ -7720,15 +7720,15 @@ static void DoTracksGroundEffect_Footprints(struct EventObject *eventObj, struct FLDEFF_DEEP_SAND_FOOTPRINTS }; - gFieldEffectArguments[0] = eventObj->previousCoords.x; - gFieldEffectArguments[1] = eventObj->previousCoords.y; + gFieldEffectArguments[0] = objEvent->previousCoords.x; + gFieldEffectArguments[1] = objEvent->previousCoords.y; gFieldEffectArguments[2] = 149; gFieldEffectArguments[3] = 2; - gFieldEffectArguments[4] = eventObj->facingDirection; + gFieldEffectArguments[4] = objEvent->facingDirection; FieldEffectStart(sandFootprints_FieldEffectData[a]); } -static void DoTracksGroundEffect_BikeTireTracks(struct EventObject *eventObj, struct Sprite *sprite, u8 a) +static void DoTracksGroundEffect_BikeTireTracks(struct ObjectEvent *objEvent, 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 @@ -7743,108 +7743,108 @@ static void DoTracksGroundEffect_BikeTireTracks(struct EventObject *eventObj, st 6, 7, 3, 4, }; - if (eventObj->currentCoords.x != eventObj->previousCoords.x || eventObj->currentCoords.y != eventObj->previousCoords.y) + if (objEvent->currentCoords.x != objEvent->previousCoords.x || objEvent->currentCoords.y != objEvent->previousCoords.y) { - gFieldEffectArguments[0] = eventObj->previousCoords.x; - gFieldEffectArguments[1] = eventObj->previousCoords.y; + gFieldEffectArguments[0] = objEvent->previousCoords.x; + gFieldEffectArguments[1] = objEvent->previousCoords.y; gFieldEffectArguments[2] = 149; gFieldEffectArguments[3] = 2; gFieldEffectArguments[4] = - bikeTireTracks_Transitions[eventObj->previousMovementDirection][eventObj->facingDirection - 5]; + bikeTireTracks_Transitions[objEvent->previousMovementDirection][objEvent->facingDirection - 5]; FieldEffectStart(FLDEFF_BIKE_TIRE_TRACKS); } } -void GroundEffect_Ripple(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_Ripple(struct ObjectEvent *objEvent, struct Sprite *sprite) { - DoRippleFieldEffect(eventObj, sprite); + DoRippleFieldEffect(objEvent, sprite); } -void GroundEffect_StepOnPuddle(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_StepOnPuddle(struct ObjectEvent *objEvent, struct Sprite *sprite) { - StartFieldEffectForEventObject(FLDEFF_SPLASH, eventObj); + StartFieldEffectForObjectEvent(FLDEFF_SPLASH, objEvent); } -void GroundEffect_SandPile(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_SandPile(struct ObjectEvent *objEvent, struct Sprite *sprite) { - StartFieldEffectForEventObject(FLDEFF_SAND_PILE, eventObj); + StartFieldEffectForObjectEvent(FLDEFF_SAND_PILE, objEvent); } -void GroundEffect_JumpOnTallGrass(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpOnTallGrass(struct ObjectEvent *objEvent, struct Sprite *sprite) { u8 spriteId; - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = 2; FieldEffectStart(FLDEFF_JUMP_TALL_GRASS); spriteId = FindTallGrassFieldEffectSpriteId( - eventObj->localId, - eventObj->mapNum, - eventObj->mapGroup, - eventObj->currentCoords.x, - eventObj->currentCoords.y); + objEvent->localId, + objEvent->mapNum, + objEvent->mapGroup, + objEvent->currentCoords.x, + objEvent->currentCoords.y); if (spriteId == MAX_SPRITES) - GroundEffect_SpawnOnTallGrass(eventObj, sprite); + GroundEffect_SpawnOnTallGrass(objEvent, sprite); } -void GroundEffect_JumpOnLongGrass(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpOnLongGrass(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = 2; FieldEffectStart(FLDEFF_JUMP_LONG_GRASS); } -void GroundEffect_JumpOnShallowWater(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpOnShallowWater(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = sprite->oam.priority; FieldEffectStart(FLDEFF_JUMP_SMALL_SPLASH); } -void GroundEffect_JumpOnWater(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpOnWater(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = sprite->oam.priority; FieldEffectStart(FLDEFF_JUMP_BIG_SPLASH); } -void GroundEffect_JumpLandingDust(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_JumpLandingDust(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; - gFieldEffectArguments[2] = eventObj->previousElevation; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; + gFieldEffectArguments[2] = objEvent->previousElevation; gFieldEffectArguments[3] = sprite->oam.priority; FieldEffectStart(FLDEFF_DUST); } -void GroundEffect_ShortGrass(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_ShortGrass(struct ObjectEvent *objEvent, struct Sprite *sprite) { - StartFieldEffectForEventObject(FLDEFF_SHORT_GRASS, eventObj); + StartFieldEffectForObjectEvent(FLDEFF_SHORT_GRASS, objEvent); } -void GroundEffect_HotSprings(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_HotSprings(struct ObjectEvent *objEvent, struct Sprite *sprite) { - StartFieldEffectForEventObject(FLDEFF_HOT_SPRINGS_WATER, eventObj); + StartFieldEffectForObjectEvent(FLDEFF_HOT_SPRINGS_WATER, objEvent); } -void GroundEffect_Seaweed(struct EventObject *eventObj, struct Sprite *sprite) +void GroundEffect_Seaweed(struct ObjectEvent *objEvent, struct Sprite *sprite) { - gFieldEffectArguments[0] = eventObj->currentCoords.x; - gFieldEffectArguments[1] = eventObj->currentCoords.y; + gFieldEffectArguments[0] = objEvent->currentCoords.x; + gFieldEffectArguments[1] = objEvent->currentCoords.y; FieldEffectStart(FLDEFF_BUBBLES); } -static void (*const sGroundEffectFuncs[])(struct EventObject *eventObj, struct Sprite *sprite) = { +static void (*const sGroundEffectFuncs[])(struct ObjectEvent *objEvent, struct Sprite *sprite) = { GroundEffect_SpawnOnTallGrass, GroundEffect_MoveOnTallGrass, GroundEffect_SpawnOnLongGrass, @@ -7867,22 +7867,22 @@ static void (*const sGroundEffectFuncs[])(struct EventObject *eventObj, struct S GroundEffect_Seaweed }; -static void StartTriggeredGroundEffects(struct EventObject *eventObj, struct Sprite *sprite, u32 flags) +static void StartTriggeredGroundEffects(struct ObjectEvent *objEvent, struct Sprite *sprite, u32 flags) { u8 i; for (i = 0; i < ARRAY_COUNT(sGroundEffectFuncs); i++, flags >>= 1) if (flags & 1) - sGroundEffectFuncs[i](eventObj, sprite); + sGroundEffectFuncs[i](objEvent, sprite); } -void FilterOutDisabledCoveringGroundEffects(struct EventObject *eventObj, u32 *flags) +void FilterOutDisabledCoveringGroundEffects(struct ObjectEvent *objEvent, u32 *flags) { - if (eventObj->disableCoveringGroundEffects) + if (objEvent->disableCoveringGroundEffects) { - eventObj->inShortGrass = 0; - eventObj->inSandPile = 0; - eventObj->inShallowFlowingWater = 0; - eventObj->inHotSprings = 0; + objEvent->inShortGrass = 0; + objEvent->inSandPile = 0; + objEvent->inShallowFlowingWater = 0; + objEvent->inHotSprings = 0; *flags &= ~(GROUND_EFFECT_FLAG_HOT_SPRINGS | GROUND_EFFECT_FLAG_SHORT_GRASS | GROUND_EFFECT_FLAG_SAND_PILE @@ -7891,111 +7891,111 @@ void FilterOutDisabledCoveringGroundEffects(struct EventObject *eventObj, u32 *f } } -void FilterOutStepOnPuddleGroundEffectIfJumping(struct EventObject *eventObj, u32 *flags) +void FilterOutStepOnPuddleGroundEffectIfJumping(struct ObjectEvent *objEvent, u32 *flags) { - if (eventObj->landingJump) + if (objEvent->landingJump) *flags &= ~GROUND_EFFECT_FLAG_PUDDLE; } -static void DoGroundEffects_OnSpawn(struct EventObject *eventObj, struct Sprite *sprite) +static void DoGroundEffects_OnSpawn(struct ObjectEvent *objEvent, struct Sprite *sprite) { u32 flags; - if (eventObj->triggerGroundEffectsOnMove) + if (objEvent->triggerGroundEffectsOnMove) { flags = 0; - UpdateEventObjectZCoordAndPriority(eventObj, sprite); - GetAllGroundEffectFlags_OnSpawn(eventObj, &flags); - SetEventObjectSpriteOamTableForLongGrass(eventObj, sprite); - StartTriggeredGroundEffects(eventObj, sprite, flags); - eventObj->triggerGroundEffectsOnMove = 0; - eventObj->disableCoveringGroundEffects = 0; + UpdateObjectEventZCoordAndPriority(objEvent, sprite); + GetAllGroundEffectFlags_OnSpawn(objEvent, &flags); + SetObjectEventSpriteOamTableForLongGrass(objEvent, sprite); + StartTriggeredGroundEffects(objEvent, sprite, flags); + objEvent->triggerGroundEffectsOnMove = 0; + objEvent->disableCoveringGroundEffects = 0; } } -static void DoGroundEffects_OnBeginStep(struct EventObject *eventObj, struct Sprite *sprite) +static void DoGroundEffects_OnBeginStep(struct ObjectEvent *objEvent, struct Sprite *sprite) { u32 flags; - if (eventObj->triggerGroundEffectsOnMove) + if (objEvent->triggerGroundEffectsOnMove) { flags = 0; - UpdateEventObjectZCoordAndPriority(eventObj, sprite); - GetAllGroundEffectFlags_OnBeginStep(eventObj, &flags); - SetEventObjectSpriteOamTableForLongGrass(eventObj, sprite); - FilterOutDisabledCoveringGroundEffects(eventObj, &flags); - StartTriggeredGroundEffects(eventObj, sprite, flags); - eventObj->triggerGroundEffectsOnMove = 0; - eventObj->disableCoveringGroundEffects = 0; + UpdateObjectEventZCoordAndPriority(objEvent, sprite); + GetAllGroundEffectFlags_OnBeginStep(objEvent, &flags); + SetObjectEventSpriteOamTableForLongGrass(objEvent, sprite); + FilterOutDisabledCoveringGroundEffects(objEvent, &flags); + StartTriggeredGroundEffects(objEvent, sprite, flags); + objEvent->triggerGroundEffectsOnMove = 0; + objEvent->disableCoveringGroundEffects = 0; } } -static void DoGroundEffects_OnFinishStep(struct EventObject *eventObj, struct Sprite *sprite) +static void DoGroundEffects_OnFinishStep(struct ObjectEvent *objEvent, struct Sprite *sprite) { u32 flags; - if (eventObj->triggerGroundEffectsOnStop) + if (objEvent->triggerGroundEffectsOnStop) { flags = 0; - UpdateEventObjectZCoordAndPriority(eventObj, sprite); - GetAllGroundEffectFlags_OnFinishStep(eventObj, &flags); - SetEventObjectSpriteOamTableForLongGrass(eventObj, sprite); - FilterOutStepOnPuddleGroundEffectIfJumping(eventObj, &flags); - StartTriggeredGroundEffects(eventObj, sprite, flags); - eventObj->triggerGroundEffectsOnStop = 0; - eventObj->landingJump = 0; + UpdateObjectEventZCoordAndPriority(objEvent, sprite); + GetAllGroundEffectFlags_OnFinishStep(objEvent, &flags); + SetObjectEventSpriteOamTableForLongGrass(objEvent, sprite); + FilterOutStepOnPuddleGroundEffectIfJumping(objEvent, &flags); + StartTriggeredGroundEffects(objEvent, sprite, flags); + objEvent->triggerGroundEffectsOnStop = 0; + objEvent->landingJump = 0; } } -bool8 FreezeEventObject(struct EventObject *eventObject) +bool8 FreezeObjectEvent(struct ObjectEvent *objectEvent) { - if (eventObject->heldMovementActive || eventObject->frozen) + if (objectEvent->heldMovementActive || objectEvent->frozen) { return TRUE; } else { - 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; + objectEvent->frozen = 1; + objectEvent->spriteAnimPausedBackup = gSprites[objectEvent->spriteId].animPaused; + objectEvent->spriteAffineAnimPausedBackup = gSprites[objectEvent->spriteId].affineAnimPaused; + gSprites[objectEvent->spriteId].animPaused = 1; + gSprites[objectEvent->spriteId].affineAnimPaused = 1; return FALSE; } } -void FreezeEventObjects(void) +void FreezeObjectEvents(void) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) - if (gEventObjects[i].active && i != gPlayerAvatar.eventObjectId) - FreezeEventObject(&gEventObjects[i]); + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) + if (gObjectEvents[i].active && i != gPlayerAvatar.objectEventId) + FreezeObjectEvent(&gObjectEvents[i]); } -void FreezeEventObjectsExceptOne(u8 eventObjectId) +void FreezeObjectEventsExceptOne(u8 objectEventId) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) - if (i != eventObjectId && gEventObjects[i].active && i != gPlayerAvatar.eventObjectId) - FreezeEventObject(&gEventObjects[i]); + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) + if (i != objectEventId && gObjectEvents[i].active && i != gPlayerAvatar.objectEventId) + FreezeObjectEvent(&gObjectEvents[i]); } -void UnfreezeEventObject(struct EventObject *eventObject) +void UnfreezeObjectEvent(struct ObjectEvent *objectEvent) { - if (eventObject->active && eventObject->frozen) + if (objectEvent->active && objectEvent->frozen) { - eventObject->frozen = 0; - gSprites[eventObject->spriteId].animPaused = eventObject->spriteAnimPausedBackup; - gSprites[eventObject->spriteId].affineAnimPaused = eventObject->spriteAffineAnimPausedBackup; + objectEvent->frozen = 0; + gSprites[objectEvent->spriteId].animPaused = objectEvent->spriteAnimPausedBackup; + gSprites[objectEvent->spriteId].affineAnimPaused = objectEvent->spriteAffineAnimPausedBackup; } } -void UnfreezeEventObjects(void) +void UnfreezeObjectEvents(void) { u8 i; - for (i = 0; i < EVENT_OBJECTS_COUNT; i++) - if (gEventObjects[i].active) - UnfreezeEventObject(&gEventObjects[i]); + for (i = 0; i < OBJECT_EVENTS_COUNT; i++) + if (gObjectEvents[i].active) + UnfreezeObjectEvent(&gObjectEvents[i]); } static void Step1(struct Sprite *sprite, u8 dir) @@ -8249,7 +8249,7 @@ bool8 SpriteAnimEnded(struct Sprite *sprite) return FALSE; } -void UpdateEventObjectSpriteVisibility(struct Sprite *sprite, bool8 invisible) +void UpdateObjectEventSpriteVisibility(struct Sprite *sprite, bool8 invisible) { u16 x, y; s16 x2, y2; @@ -8276,19 +8276,19 @@ void UpdateEventObjectSpriteVisibility(struct Sprite *sprite, bool8 invisible) sprite->invisible = TRUE; } -static void UpdateEventObjectSpriteSubpriorityAndVisibility(struct Sprite *sprite) +static void UpdateObjectEventSpriteSubpriorityAndVisibility(struct Sprite *sprite) { SetObjectSubpriorityByZCoord(sprite->data[1], sprite, 1); - UpdateEventObjectSpriteVisibility(sprite, 0); + UpdateObjectEventSpriteVisibility(sprite, 0); } -void TurnEventObject(u8 eventObjectId, u8 direction) +void TurnObjectEvent(u8 objectEventId, u8 direction) { u8 i; for (i = 0; i < MAX_SPRITES; i++) { struct Sprite *sprite = &gSprites[i]; - if (sprite->inUse && sprite->callback == UpdateEventObjectSpriteSubpriorityAndVisibility && (u8)sprite->data[0] == eventObjectId) + if (sprite->inUse && sprite->callback == UpdateObjectEventSpriteSubpriorityAndVisibility && (u8)sprite->data[0] == objectEventId) { u8 animNum = GetFaceDirectionAnimNum(direction); StartSpriteAnim(sprite, animNum); @@ -8297,24 +8297,24 @@ void TurnEventObject(u8 eventObjectId, u8 direction) } } -u32 StartFieldEffectForEventObject(u8 fieldEffectId, struct EventObject *eventObject) +u32 StartFieldEffectForObjectEvent(u8 fieldEffectId, struct ObjectEvent *objectEvent) { - EventObjectGetLocalIdAndMap(eventObject, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); + ObjectEventGetLocalIdAndMap(objectEvent, &gFieldEffectArguments[0], &gFieldEffectArguments[1], &gFieldEffectArguments[2]); return FieldEffectStart(fieldEffectId); } -void DoShadowFieldEffect(struct EventObject *eventObject) +void DoShadowFieldEffect(struct ObjectEvent *objectEvent) { - if (!eventObject->hasShadow) + if (!objectEvent->hasShadow) { - eventObject->hasShadow = 1; - StartFieldEffectForEventObject(FLDEFF_SHADOW, eventObject); + objectEvent->hasShadow = 1; + StartFieldEffectForObjectEvent(FLDEFF_SHADOW, objectEvent); } } -static void DoRippleFieldEffect(struct EventObject *eventObject, struct Sprite *sprite) +static void DoRippleFieldEffect(struct ObjectEvent *objectEvent, struct Sprite *sprite) { - const struct EventObjectGraphicsInfo *graphicsInfo = GetEventObjectGraphicsInfo(eventObject->graphicsId); + const struct ObjectEventGraphicsInfo *graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId); gFieldEffectArguments[0] = sprite->pos1.x; gFieldEffectArguments[1] = sprite->pos1.y + (graphicsInfo->height >> 1) - 2; gFieldEffectArguments[2] = 151; |