Merge branch 'master' of github.com:pret/pokefirered into add_arm_agbcc

src/event_object_80688E4.c

@@ -0,0 +1,653 @@
+#include "global.h"
+#include "event_object_80688E4.h"
+#include "event_object_movement.h"
+#include "field_effect.h"
+#include "field_ground_effect.h"
+
+// This is part of evobjmv.c (see assert statement in DoObjectUnionRoomWarpYDisplacement).
+
+static void DoObjectUnionRoomWarpYDisplacement(struct Sprite * sprite);
+
+bool8 FreezeObjectEvent(struct ObjectEvent * objectEvent)
+{
+    if (objectEvent->heldMovementActive || objectEvent->frozen)
+        return TRUE;
+    objectEvent->frozen = TRUE;
+    objectEvent->spriteAnimPausedBackup = gSprites[objectEvent->spriteId].animPaused;
+    objectEvent->spriteAffineAnimPausedBackup = gSprites[objectEvent->spriteId].affineAnimPaused;
+    gSprites[objectEvent->spriteId].animPaused = TRUE;
+    gSprites[objectEvent->spriteId].affineAnimPaused = TRUE;
+    return FALSE;
+}
+
+void FreezeObjectEvents(void)
+{
+    u8 i;
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        if (gObjectEvents[i].active && i != gPlayerAvatar.objectEventId)
+            FreezeObjectEvent(&gObjectEvents[i]);
+    }
+}
+
+void FreezeObjectEventsExceptOne(u8 noFreeze)
+{
+    u8 i;
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        if (i != noFreeze && gObjectEvents[i].active && i != gPlayerAvatar.objectEventId)
+            FreezeObjectEvent(&gObjectEvents[i]);
+    }
+}
+
+void UnfreezeObjectEvent(struct ObjectEvent * objectEvent)
+{
+    if (objectEvent->active && objectEvent->frozen)
+    {
+        objectEvent->frozen = FALSE;
+        gSprites[objectEvent->spriteId].animPaused = objectEvent->spriteAnimPausedBackup;
+        gSprites[objectEvent->spriteId].affineAnimPaused = objectEvent->spriteAffineAnimPausedBackup;
+    }
+}
+
+void UnfreezeObjectEvents(void)
+{
+    u8 i;
+    for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
+    {
+        if (gObjectEvents[i].active)
+            UnfreezeObjectEvent(&gObjectEvents[i]);
+    }
+}
+
+#define tObjectEventId data[0]
+#define tZCoord        data[1]
+#define tInvisible     data[2]
+
+#define tDirection data[3]
+#define tSpeed     data[4]
+#define tStepNo    data[5]
+
+static void little_step(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += gUnknown_83A64C8[direction].x;
+    sprite->pos1.y += gUnknown_83A64C8[direction].y;
+}
+
+static void double_little_steps(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += 2 * gUnknown_83A64C8[direction].x;
+    sprite->pos1.y += 2 * gUnknown_83A64C8[direction].y;
+}
+
+static void triple_little_steps(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += 2 * gUnknown_83A64C8[direction].x + gUnknown_83A64C8[direction].x;
+    sprite->pos1.y += 2 * gUnknown_83A64C8[direction].y + gUnknown_83A64C8[direction].y;
+}
+
+static void quad_little_steps(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += 4 * gUnknown_83A64C8[direction].x;
+    sprite->pos1.y += 4 * gUnknown_83A64C8[direction].y;
+}
+
+static void oct_little_steps(struct Sprite * sprite, u8 direction)
+{
+    sprite->pos1.x += 8 * gUnknown_83A64C8[direction].x;
+    sprite->pos1.y += 8 * gUnknown_83A64C8[direction].y;
+}
+
+void oamt_npc_ministep_reset(struct Sprite * sprite, u8 direction, u8 speed)
+{
+    sprite->tDirection = direction;
+    sprite->tSpeed = speed;
+    sprite->tStepNo = 0;
+}
+
+typedef void (*SpriteStepFunc)(struct Sprite *sprite, u8 direction);
+
+static const SpriteStepFunc sSpeed0[] = {
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step,
+    little_step
+};
+
+static const SpriteStepFunc sSpeed1[] = {
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps,
+    double_little_steps
+};
+
+static const SpriteStepFunc sSpeed2[] = {
+    double_little_steps,
+    triple_little_steps,
+    triple_little_steps,
+    double_little_steps,
+    triple_little_steps,
+    triple_little_steps
+};
+
+static const SpriteStepFunc sSpeed3[] = {
+    quad_little_steps,
+    quad_little_steps,
+    quad_little_steps,
+    quad_little_steps
+};
+
+static const SpriteStepFunc sSpeed4[] = {
+    oct_little_steps,
+    oct_little_steps
+};
+
+static const SpriteStepFunc *const sSpriteStepFuncsBySpeed[] = {
+    sSpeed0,
+    sSpeed1,
+    sSpeed2,
+    sSpeed3,
+    sSpeed4
+};
+
+static const s16 sSpriteStepCountsBySpeed[] = {
+    NELEMS(sSpeed0),
+    NELEMS(sSpeed1),
+    NELEMS(sSpeed2),
+    NELEMS(sSpeed3),
+    NELEMS(sSpeed4)
+};
+
+bool8 obj_npc_ministep(struct Sprite *sprite)
+{
+    if (sprite->tStepNo >= sSpriteStepCountsBySpeed[sprite->tSpeed])
+        return FALSE;
+
+    sSpriteStepFuncsBySpeed[sprite->tSpeed][sprite->tStepNo](sprite, sprite->tDirection);
+
+    sprite->tStepNo++;
+
+    if (sprite->tStepNo < sSpriteStepCountsBySpeed[sprite->tSpeed])
+        return FALSE;
+
+    return TRUE;
+}
+
+#undef tStepNo
+#undef tSpeed
+#undef tDirection
+
+#define tDirection data[3]
+#define tDelay     data[4]
+#define tStepNo    data[5]
+
+void sub_8068BBC(struct Sprite *sprite, u8 direction)
+{
+    sprite->tDirection = direction;
+    sprite->tDelay = 0;
+    sprite->tStepNo = 0;
+}
+
+bool8 sub_8068BCC(struct Sprite *sprite)
+{
+    if (!(sprite->tDelay & 1))
+    {
+        little_step(sprite, sprite->tDirection);
+        sprite->tStepNo++;
+    }
+
+    sprite->tDelay++;
+
+    if (sprite->tStepNo > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_8068C08(struct Sprite *sprite, u8 direction)
+{
+    sprite->tDirection = direction;
+    sprite->tDelay = 0;
+    sprite->tStepNo = 0;
+}
+
+bool8 sub_8068C18(struct Sprite *sprite)
+{
+    if (++sprite->tDelay < 3)
+    {
+        little_step(sprite, sprite->tDirection);
+        sprite->tStepNo++;
+    }
+    else
+        sprite->tDelay = 0;
+
+    if (sprite->tStepNo > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_8068C58(struct Sprite *sprite, u8 direction)
+{
+    sprite->tDirection = direction;
+    sprite->tDelay = 0;
+    sprite->tStepNo = 0;
+}
+
+bool8 sub_8068C68(struct Sprite *sprite)
+{
+    if (++sprite->tDelay > 9)
+    {
+        sprite->tDelay = 0;
+        little_step(sprite, sprite->tDirection);
+        sprite->tStepNo++;
+    }
+
+    if (sprite->tStepNo > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_8068CA4(struct Sprite *sprite, u8 direction)
+{
+    sprite->tDirection = direction;
+    sprite->tDelay = 0;
+    sprite->tStepNo = 0;
+}
+
+bool8 sub_8068CB4(struct Sprite *sprite)
+{
+    if ((++sprite->tDelay) & 1)
+    {
+        little_step(sprite, sprite->tDirection);
+        sprite->tStepNo++;
+    }
+    else
+    {
+        double_little_steps(sprite, sprite->tDirection);
+        sprite->tStepNo += 2;
+    }
+
+    if (sprite->tStepNo > 15)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+#undef tStepNo
+#undef tDelay
+#undef tDirection
+
+#define tDirection  data[3]
+#define tJumpSpeed  data[4]
+#define tJumpHeight data[5]
+#define tStepNo     data[6]
+
+static const s8 sJumpHeight12[] = {
+    -4,  -6,  -8, -10, -11, -12, -12, -12, -11, -10,  -9,  -8,  -6,  -4,   0,   0
+};
+
+static const s8 sJumpHeight6[] = {
+    0,  -2,  -3,  -4,  -5,  -6,  -6,  -6,  -5,  -5,  -4,  -3,  -2,   0,   0,   0
+};
+
+static const s8 sJumpHeight10[] = {
+    -2,  -4,  -6,  -8,  -9, -10, -10, -10,  -9,  -8,  -6,  -5,  -3,  -2,   0,   0
+};
+
+static const s8 *const sYDisplacementPtrs[] = {
+    sJumpHeight12,
+    sJumpHeight6,
+    sJumpHeight10
+};
+
+static s16 GetJumpYDisplacement(s16 stepno, u8 jumpno)
+{
+    return sYDisplacementPtrs[jumpno][stepno];
+}
+
+void sub_8068D1C(struct Sprite *sprite, u8 direction, u8 speed, u8 height)
+{
+    sprite->tDirection = direction;
+    sprite->tJumpSpeed = speed;
+    sprite->tJumpHeight = height;
+    sprite->tStepNo = 0;
+}
+
+u8 sub_8068D3C(struct Sprite *sprite)
+{
+    s16 duration[3] = {0x10, 0x10, 0x20};
+    u8 shifts[3] = {0, 0, 1};
+    u8 jumpPhase = 0;
+
+    if (sprite->tJumpSpeed != 0)
+        little_step(sprite, sprite->tDirection);
+
+    sprite->pos2.y = GetJumpYDisplacement(sprite->tStepNo >> shifts[sprite->tJumpSpeed], sprite->tJumpHeight);
+
+    sprite->tStepNo++;
+
+    if (sprite->tStepNo == (duration[sprite->tJumpSpeed] >> 1))
+        jumpPhase = 1;
+
+    if (sprite->tStepNo >= duration[sprite->tJumpSpeed])
+    {
+        sprite->pos2.y = 0;
+        jumpPhase = -1;
+    }
+
+    return jumpPhase;
+}
+
+u8 sub_8068DC4(struct Sprite *sprite)
+{
+    s16 duration[3] = {0x20, 0x20, 0x40};
+    u8 shifts[3] = {1, 1, 2};
+    u8 jumpPhase = 0;
+
+    if (sprite->tJumpSpeed != 0 && !(sprite->tStepNo & 1))
+        little_step(sprite, sprite->tDirection);
+
+    sprite->pos2.y = GetJumpYDisplacement(sprite->tStepNo >> shifts[sprite->tJumpSpeed], sprite->tJumpHeight);
+
+    sprite->tStepNo++;
+
+    if (sprite->tStepNo == (duration[sprite->tJumpSpeed] >> 1))
+        jumpPhase = 1;
+
+    if (sprite->tStepNo >= duration[sprite->tJumpSpeed])
+    {
+        sprite->pos2.y = 0;
+        jumpPhase = -1;
+    }
+
+    return jumpPhase;
+}
+
+#undef tStepNo
+#undef tJumpHeight
+#undef tJumpSpeed
+#undef tDirection
+
+#define tDelay data[3]
+
+void SetObjectEventStepTimer(struct Sprite *sprite, s16 delay)
+{
+    sprite->tDelay = delay;
+}
+
+bool8 RunObjectEventStepTimer(struct Sprite *sprite)
+{
+    sprite->tDelay--;
+
+    if (sprite->tDelay == 0)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+#undef tDelay
+
+void obj_anim_image_set_and_seek(struct Sprite *sprite, u8 animNum, u8 animCmdIndex)
+{
+    sprite->animNum = animNum;
+    sprite->animPaused = FALSE;
+    SeekSpriteAnim(sprite, animCmdIndex);
+}
+
+bool8 SpriteAnimEnded(struct Sprite *sprite)
+{
+    if (sprite->animEnded)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void UpdateObjectEventSpriteVisibility(struct Sprite *sprite, bool8 invisible)
+{
+    u16 x, y;
+    s16 x2, y2;
+
+    sprite->invisible = invisible;
+
+    if (sprite->coordOffsetEnabled)
+    {
+        x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX + gSpriteCoordOffsetX;
+        y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY;
+    }
+    else
+    {
+        x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX;
+        y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY;
+    }
+
+    x2 = x - (sprite->centerToCornerVecX >> 1);
+    y2 = y - (sprite->centerToCornerVecY >> 1);
+
+    if ((s16)x > 255 || x2 < -16)
+        sprite->invisible = TRUE;
+    if ((s16)y > 175 || y2 < -16)
+        sprite->invisible = TRUE;
+}
+
+void UpdateObjectEventSpriteSubpriorityAndVisibility(struct Sprite *sprite)
+{
+    DoObjectUnionRoomWarpYDisplacement(sprite);
+    SetObjectSubpriorityByZCoord(sprite->tZCoord, sprite, 1);
+    UpdateObjectEventSpriteVisibility(sprite, sprite->tInvisible);
+}
+
+void sub_8068FD0(void)
+{
+    s32 i;
+    for (i = 0; i < MAX_SPRITES; i++)
+    {
+        struct Sprite *sprite = &gSprites[i];
+        if (sprite->inUse && sprite->callback == UpdateObjectEventSpriteSubpriorityAndVisibility)
+        {
+            DestroySprite(sprite);
+        }
+    }
+}
+
+#define tUnionRoomWarpAnimNo    data[3]
+#define tUnionRoomWarpAnimState data[4]
+
+static int GetObjectEventSpriteId(u8 objectEventId)
+{
+    int i;
+    for (i = 0; i < MAX_SPRITES; i++)
+    {
+        struct Sprite *sprite = &gSprites[i];
+        if (sprite->inUse && sprite->callback == UpdateObjectEventSpriteSubpriorityAndVisibility && (u8)sprite->tObjectEventId == objectEventId)
+        {
+            return i;
+        }
+    }
+    return MAX_SPRITES;
+}
+
+void TurnObjectEvent(u8 objectEventId, u8 direction)
+{
+    u8 animNum;
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId != MAX_SPRITES)
+    {
+        struct Sprite *sprite = &gSprites[spriteId];
+        StartSpriteAnim(sprite, ObjectEventDirectionToImageAnimId(direction));
+    }
+}
+
+void RfuUnionObjectSetFacingDirection(u8 objectEventId, u8 direction)
+{
+    u8 animNum;
+    int spriteId = GetObjectEventSpriteId(objectEventId);
+    u16 baseBlock;
+    if (spriteId != MAX_SPRITES)
+    {
+        struct Sprite *sprite = &gSprites[spriteId];
+        const struct ObjectEventGraphicsInfo * info = GetObjectEventGraphicsInfo(direction);
+        baseBlock = sprite->oam.tileNum;
+        sprite->oam = *info->oam;
+        sprite->oam.tileNum = baseBlock;
+        sprite->oam.paletteNum = info->paletteSlot;
+        sprite->images = info->images;
+        if (info->subspriteTables == NULL)
+        {
+            sprite->subspriteTables = NULL;
+            sprite->subspriteTableNum = 0;
+            sprite->subspriteMode = SUBSPRITES_OFF;
+        }
+        else
+        {
+            SetSubspriteTables(sprite, info->subspriteTables);
+            sprite->subspriteMode = SUBSPRITES_IGNORE_PRIORITY;
+        }
+        StartSpriteAnim(sprite, 0);
+    }
+}
+
+void RfuUnionObjectToggleInvisibility(u8 objectEventId, bool32 arg1)
+{
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId != MAX_SPRITES)
+    {
+        if (arg1)
+            gSprites[spriteId].tInvisible = TRUE;
+        else
+            gSprites[spriteId].tInvisible = FALSE;
+    }
+}
+
+bool32 RfuUnionObjectIsInvisible(u8 objectEventId)
+{
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId == MAX_SPRITES)
+        return FALSE;
+    return gSprites[spriteId].tInvisible == TRUE;
+}
+
+void RfuUnionObjectStartWarp(u8 objectEventId, u8 direction)
+{
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId != MAX_SPRITES)
+    {
+        gSprites[spriteId].tUnionRoomWarpAnimNo = direction;
+        gSprites[spriteId].tUnionRoomWarpAnimState = 0;
+    }
+}
+
+static void DoObjectUnionRoomWarpYDisplacementUpwards(struct Sprite * sprite)
+{
+    switch (sprite->tUnionRoomWarpAnimState)
+    {
+    case 0:
+        sprite->pos2.y = 0;
+        sprite->tUnionRoomWarpAnimState++;
+        // fallthrough
+    case 1:
+        if ((sprite->pos2.y -= 8) == -160)
+        {
+            sprite->pos2.y = 0;
+            sprite->tInvisible = 1;
+            sprite->tUnionRoomWarpAnimNo = 0;
+            sprite->tUnionRoomWarpAnimState = 0;
+        }
+        break;
+    }
+}
+
+static void DoObjectUnionRoomWarpYDisplacementDownwards(struct Sprite * sprite)
+{
+    switch (sprite->tUnionRoomWarpAnimState)
+    {
+    case 0:
+        sprite->pos2.y = -160;
+        sprite->tUnionRoomWarpAnimState++;
+        // fallthrough
+    case 1:
+        if ((sprite->pos2.y += 8) == 0)
+        {
+            sprite->tUnionRoomWarpAnimNo = 0;
+            sprite->tUnionRoomWarpAnimState = 0;
+        }
+        break;
+    }
+}
+
+static void DoObjectUnionRoomWarpYDisplacement(struct Sprite * sprite)
+{
+    switch (sprite->tUnionRoomWarpAnimNo)
+    {
+    case 0:
+        break;
+    case 1:
+        DoObjectUnionRoomWarpYDisplacementDownwards(sprite);
+        break;
+    case 2:
+        DoObjectUnionRoomWarpYDisplacementUpwards(sprite);
+        break;
+    default:
+        sprite->tUnionRoomWarpAnimNo = 0;
+        AGB_ASSERT_EX(0, ABSPATH("evobjmv.c"), 13331);
+    }
+}
+
+bool32 RfuUnionObjectIsWarping(u8 objectEventId)
+{
+    u8 spriteId = GetObjectEventSpriteId(objectEventId);
+    if (spriteId == MAX_SPRITES)
+        return FALSE;
+    if (gSprites[spriteId].tUnionRoomWarpAnimNo)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+#undef tUnionRoomWarpAnimState
+#undef tUnionRoomWarpAnimNo
+#undef tInvisible
+#undef tZCoord
+#undef tObjectEventId
+
+u32 oe_exec_and_other_stuff(u8 fieldEffectId, struct ObjectEvent * objectEvent)
+{
+    ObjectEventGetLocalIdAndMap(objectEvent, (u8 *)&gFieldEffectArguments[0], (u8 *)&gFieldEffectArguments[1], (u8 *)&gFieldEffectArguments[2]);
+    return FieldEffectStart(fieldEffectId);
+}
+
+void DoShadowFieldEffect(struct ObjectEvent *objectEvent)
+{
+    if (!objectEvent->hasShadow)
+    {
+        objectEvent->hasShadow = TRUE;
+        oe_exec_and_other_stuff(FLDEFF_SHADOW, objectEvent);
+    }
+}
+
+void DoRippleFieldEffect(struct ObjectEvent *objectEvent, struct Sprite *sprite)
+{
+    const struct ObjectEventGraphicsInfo *graphicsInfo = GetObjectEventGraphicsInfo(objectEvent->graphicsId);
+    gFieldEffectArguments[0] = sprite->pos1.x;
+    gFieldEffectArguments[1] = sprite->pos1.y + (graphicsInfo->height >> 1) - 2;
+    gFieldEffectArguments[2] = 151;
+    gFieldEffectArguments[3] = 3;
+    FieldEffectStart(FLDEFF_RIPPLE);
+}

src/event_object_lock.c

@@ -51,7 +51,7 @@ void sub_80695CC(u8 taskId)
         task->data[0] = 1;
     }
 
-    if (task->data[1] == 0 && !gObjectEvents[gSelectedObjectEvent].mapobj_bit_1)
+    if (task->data[1] == 0 && !gObjectEvents[gSelectedObjectEvent].singleMovementActive)
     {
         FreezeObjectEvent(&gObjectEvents[gSelectedObjectEvent]);
         task->data[1] = 1;
@@ -78,7 +78,7 @@ void LockSelectedObjectEvent(void)
 
     FreezeObjectEventsExceptOne(gSelectedObjectEvent);
     taskId = CreateTask(sub_80695CC, 80);
-    if (!gObjectEvents[gSelectedObjectEvent].mapobj_bit_1)
+    if (!gObjectEvents[gSelectedObjectEvent].singleMovementActive)
     {
         FreezeObjectEvent(&gObjectEvents[gSelectedObjectEvent]);
         gTasks[taskId].data[1] = 1;

src/field_fadetransition.c

@@ -850,7 +850,7 @@ static void sub_807EAC4(s16 a0, s16 a1, s16 *a2, s16 *a3, s16 *a4)
     (*a4)++;
     playerSpr->pos2.x = *a2 >> 5;
     playerSpr->pos2.y = *a3 >> 5;
-    if (playerObj->mapobj_bit_7)
+    if (playerObj->heldMovementFinished)
     {
         ObjectEventForceSetSpecialAnim(playerObj, GetStepInPlaceDelay16AnimId(GetPlayerFacingDirection()));
     }

src/field_specials.c

@@ -316,7 +316,7 @@ void Special_AnimatePcTurnOff()
 void SpawnCameraObject(void)
 {
     u8 objectEventId = SpawnSpecialObjectEventParameterized(OBJECT_EVENT_GFX_YOUNGSTER, 8, 127, gSaveBlock1Ptr->pos.x + 7, gSaveBlock1Ptr->pos.y + 7, 3);
-    gObjectEvents[objectEventId].mapobj_bit_13 = TRUE;
+    gObjectEvents[objectEventId].invisible = TRUE;
     CameraObjectSetFollowedObjectId(gObjectEvents[objectEventId].spriteId);
 }
 

src/quest_log_objects.c

@@ -14,22 +14,22 @@ void SetQuestLogObjectEventsData(struct QuestLog * questLog)
     for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
     {
         questLog->unk_008[i].active = gObjectEvents[i].active;
-        questLog->unk_008[i].mapobj_bit_3 = gObjectEvents[i].mapobj_bit_3;
-        questLog->unk_008[i].mapobj_bit_4 = gObjectEvents[i].mapobj_bit_4;
-        questLog->unk_008[i].mapobj_bit_5 = gObjectEvents[i].mapobj_bit_5;
-        questLog->unk_008[i].mapobj_bit_8 = gObjectEvents[i].mapobj_bit_8;
-        questLog->unk_008[i].mapobj_bit_9 = gObjectEvents[i].mapobj_bit_9;
-        questLog->unk_008[i].mapobj_bit_10 = gObjectEvents[i].mapobj_bit_10;
-        questLog->unk_008[i].mapobj_bit_11 = gObjectEvents[i].mapobj_bit_11;
-        questLog->unk_008[i].mapobj_bit_12 = gObjectEvents[i].mapobj_bit_12;
-        questLog->unk_008[i].mapobj_bit_13 = gObjectEvents[i].mapobj_bit_13;
-        questLog->unk_008[i].mapobj_bit_14 = gObjectEvents[i].mapobj_bit_14;
-        questLog->unk_008[i].mapobj_bit_15 = gObjectEvents[i].mapobj_bit_15;
-        questLog->unk_008[i].mapobj_bit_16 = gObjectEvents[i].mapobj_bit_16;
-        questLog->unk_008[i].mapobj_bit_23 = gObjectEvents[i].mapobj_bit_23;
-        questLog->unk_008[i].mapobj_bit_24 = gObjectEvents[i].mapobj_bit_24;
-        questLog->unk_008[i].mapobj_bit_25 = gObjectEvents[i].mapobj_bit_25;
-        questLog->unk_008[i].mapobj_bit_26 = gObjectEvents[i].mapobj_bit_26;
+        questLog->unk_008[i].triggerGroundEffectsOnStop = gObjectEvents[i].triggerGroundEffectsOnStop;
+        questLog->unk_008[i].disableCoveringGroundEffects = gObjectEvents[i].disableCoveringGroundEffects;
+        questLog->unk_008[i].landingJump = gObjectEvents[i].landingJump;
+        questLog->unk_008[i].frozen = gObjectEvents[i].frozen;
+        questLog->unk_008[i].facingDirectionLocked = gObjectEvents[i].facingDirectionLocked;
+        questLog->unk_008[i].disableAnim = gObjectEvents[i].disableAnim;
+        questLog->unk_008[i].enableAnim = gObjectEvents[i].enableAnim;
+        questLog->unk_008[i].inanimate = gObjectEvents[i].inanimate;
+        questLog->unk_008[i].invisible = gObjectEvents[i].invisible;
+        questLog->unk_008[i].offScreen = gObjectEvents[i].offScreen;
+        questLog->unk_008[i].trackedByCamera = gObjectEvents[i].trackedByCamera;
+        questLog->unk_008[i].isPlayer = gObjectEvents[i].isPlayer;
+        questLog->unk_008[i].spriteAnimPausedBackup = gObjectEvents[i].spriteAnimPausedBackup;
+        questLog->unk_008[i].spriteAffineAnimPausedBackup = gObjectEvents[i].spriteAffineAnimPausedBackup;
+        questLog->unk_008[i].disableJumpLandingGroundEffect = gObjectEvents[i].disableJumpLandingGroundEffect;
+        questLog->unk_008[i].fixedPriority = gObjectEvents[i].fixedPriority;
         questLog->unk_008[i].mapobj_unk_18 = gObjectEvents[i].facingDirection;
         questLog->unk_008[i].mapobj_unk_0B_0 = gObjectEvents[i].mapobj_unk_0B_0;
         questLog->unk_008[i].elevation = gObjectEvents[i].elevation;
@@ -58,22 +58,22 @@ void sub_815A1F8(const struct QuestLog * questLog, const struct ObjectEventTempl
     for (i = 0; i < OBJECT_EVENTS_COUNT; i++)
     {
         gObjectEvents[i].active = questLogObjectEvents[i].active;
-        gObjectEvents[i].mapobj_bit_3 = questLogObjectEvents[i].mapobj_bit_3;
-        gObjectEvents[i].mapobj_bit_4 = questLogObjectEvents[i].mapobj_bit_4;
-        gObjectEvents[i].mapobj_bit_5 = questLogObjectEvents[i].mapobj_bit_5;
-        gObjectEvents[i].mapobj_bit_8 = questLogObjectEvents[i].mapobj_bit_8;
-        gObjectEvents[i].mapobj_bit_9 = questLogObjectEvents[i].mapobj_bit_9;
-        gObjectEvents[i].mapobj_bit_10 = questLogObjectEvents[i].mapobj_bit_10;
-        gObjectEvents[i].mapobj_bit_11 = questLogObjectEvents[i].mapobj_bit_11;
-        gObjectEvents[i].mapobj_bit_12 = questLogObjectEvents[i].mapobj_bit_12;
-        gObjectEvents[i].mapobj_bit_13 = questLogObjectEvents[i].mapobj_bit_13;
-        gObjectEvents[i].mapobj_bit_14 = questLogObjectEvents[i].mapobj_bit_14;
-        gObjectEvents[i].mapobj_bit_15 = questLogObjectEvents[i].mapobj_bit_15;
-        gObjectEvents[i].mapobj_bit_16 = questLogObjectEvents[i].mapobj_bit_16;
-        gObjectEvents[i].mapobj_bit_23 = questLogObjectEvents[i].mapobj_bit_23;
-        gObjectEvents[i].mapobj_bit_24 = questLogObjectEvents[i].mapobj_bit_24;
-        gObjectEvents[i].mapobj_bit_25 = questLogObjectEvents[i].mapobj_bit_25;
-        gObjectEvents[i].mapobj_bit_26 = questLogObjectEvents[i].mapobj_bit_26;
+        gObjectEvents[i].triggerGroundEffectsOnStop = questLogObjectEvents[i].triggerGroundEffectsOnStop;
+        gObjectEvents[i].disableCoveringGroundEffects = questLogObjectEvents[i].disableCoveringGroundEffects;
+        gObjectEvents[i].landingJump = questLogObjectEvents[i].landingJump;
+        gObjectEvents[i].frozen = questLogObjectEvents[i].frozen;
+        gObjectEvents[i].facingDirectionLocked = questLogObjectEvents[i].facingDirectionLocked;
+        gObjectEvents[i].disableAnim = questLogObjectEvents[i].disableAnim;
+        gObjectEvents[i].enableAnim = questLogObjectEvents[i].enableAnim;
+        gObjectEvents[i].inanimate = questLogObjectEvents[i].inanimate;
+        gObjectEvents[i].invisible = questLogObjectEvents[i].invisible;
+        gObjectEvents[i].offScreen = questLogObjectEvents[i].offScreen;
+        gObjectEvents[i].trackedByCamera = questLogObjectEvents[i].trackedByCamera;
+        gObjectEvents[i].isPlayer = questLogObjectEvents[i].isPlayer;
+        gObjectEvents[i].spriteAnimPausedBackup = questLogObjectEvents[i].spriteAnimPausedBackup;
+        gObjectEvents[i].spriteAffineAnimPausedBackup = questLogObjectEvents[i].spriteAffineAnimPausedBackup;
+        gObjectEvents[i].disableJumpLandingGroundEffect = questLogObjectEvents[i].disableJumpLandingGroundEffect;
+        gObjectEvents[i].fixedPriority = questLogObjectEvents[i].fixedPriority;
         gObjectEvents[i].facingDirection = questLogObjectEvents[i].mapobj_unk_18;
         gObjectEvents[i].mapobj_unk_0B_0 = questLogObjectEvents[i].mapobj_unk_0B_0;
         gObjectEvents[i].elevation = questLogObjectEvents[i].elevation;

src/quest_log_player.c

@@ -100,7 +100,7 @@ static void sub_81505C4(u8 taskId)
     {
         case 0:
             ObjectEventClearAnimIfSpecialAnimActive(objectEvent);
-            objectEvent->mapobj_bit_11 = TRUE;
+            objectEvent->enableAnim = TRUE;
             sub_81507BC(objectEvent, sub_805C808(4));
             StartSpriteAnim(sprite, sub_80634F0(objectEvent->facingDirection));
             gTasks[taskId].data[0]++;

src/rfu_union_tool.c

@@ -70,11 +70,11 @@ static const u8 sOppositeFacingDirection[] = {
 };
 
 static const u8 gUnknown_845711B[] = {
-    DIR_SOUTH,
-    DIR_WEST,
-    DIR_SOUTH,
-    DIR_EAST,
-    DIR_NORTH
+    [DIR_NONE]  = DIR_SOUTH,
+    [DIR_SOUTH] = DIR_WEST,
+    [DIR_NORTH] = DIR_SOUTH,
+    [DIR_WEST]  = DIR_EAST,
+    [DIR_EAST]  = DIR_NORTH
 };
 
 static const u8 sUnionRoomLocalIds[] = {
@@ -441,7 +441,7 @@ void sub_811BAAC(u8 * sp8, s32 r9)
     {
         s32 r5 = 5 * r9 + r7;
         sp8[r5] = sprite_new(OBJECT_EVENT_GFX_MAN, r5 - 0x38, sUnionPartnerCoords[r9][0] + sFacingDirectionOffsets[r7][0], sUnionPartnerCoords[r9][1] + sFacingDirectionOffsets[r7][1], 3, 1);
-        sub_8069124(r5 - 0x38, TRUE);
+        RfuUnionObjectToggleInvisibility(r5 - 0x38, TRUE);
     }
 }
 
@@ -485,7 +485,7 @@ static u8 UnionPartnerObjectGetFacing(u32 r1, u32 unused, struct GFtgtGname * gn
 
 static u32 sub_811BBC8(u32 a0, u32 a1)
 {
-    return sub_806916C(5 * a0 + a1 - 0x38);
+    return RfuUnionObjectIsInvisible(5 * a0 + a1 - 0x38);
 }
 
 static void sub_811BBE0(u32 r5, u32 r6, u8 r8, struct GFtgtGname * gname)
@@ -494,10 +494,10 @@ static void sub_811BBE0(u32 r5, u32 r6, u8 r8, struct GFtgtGname * gname)
     s32 r7 = 5 * r5 + r6;
     if (sub_811BBC8(r5, r6) == 1)
     {
-        sub_8069124(r7 - 0x38, FALSE);
-        sub_80691A4(r7 - 0x38, 1);
+        RfuUnionObjectToggleInvisibility(r7 - 0x38, FALSE);
+        RfuUnionObjectStartWarp(r7 - 0x38, 1);
     }
-    sub_8069094(r7 - 0x38, r8);
+    RfuUnionObjectSetFacingDirection(r7 - 0x38, r8);
     UnionPartnerObjectSetFacing(r6, r5, UnionPartnerObjectGetFacing(r6, r5, gname));
     GetUnionRoomPlayerFacingCoords(r5, r6, &x, &y);
     sub_8059024(x, y, 1);
@@ -506,7 +506,7 @@ static void sub_811BBE0(u32 r5, u32 r6, u8 r8, struct GFtgtGname * gname)
 static void sub_811BC68(u32 a0, u32 a1)
 {
     s32 x, y;
-    sub_80691A4(5 * a0 + a1 - 0x38, 2);
+    RfuUnionObjectStartWarp(5 * a0 + a1 - 0x38, 2);
     GetUnionRoomPlayerFacingCoords(a0, a1, &x, &y);
     sub_8059024(x, y, 0);
 }
@@ -518,7 +518,7 @@ static void sub_811BCA0(u32 r7, struct GFtgtGname * r8)
 
     PlayerGetDestCoords(&x, &y);
     player_get_pos_including_state_based_drift(&x2, &y2);
-    if (sub_806916C(5 * r7 - 0x38) == 1)
+    if (RfuUnionObjectIsInvisible(5 * r7 - 0x38) == 1)
     {
         if (sub_811B58C(r7, 0, x, y) == TRUE || sub_811B58C(r7, 0, x2, y2) == TRUE)
         {
@@ -631,11 +631,11 @@ bool32 sub_811BF00(struct UnkStruct_Main0 *arg0, s16 *arg1, s16 *arg2, u8 *arg3)
             {
                 continue;
             }
-            if (sub_806916C(r3 - 0x38) != 0)
+            if (RfuUnionObjectIsInvisible(r3 - 0x38) != 0)
             {
                 continue;
             }
-            if (sub_8069294(r3 - 0x38) != 0)
+            if (RfuUnionObjectIsWarping(r3 - 0x38) != 0)
             {
                 continue;
             }
@@ -654,7 +654,7 @@ bool32 sub_811BF00(struct UnkStruct_Main0 *arg0, s16 *arg1, s16 *arg2, u8 *arg3)
 
 static void UnionPartnerObjectSetFacing(s32 arg0, s32 arg1, u8 arg2)
 {
-    sub_8069058(5 * arg1 - 0x38 + arg0, arg2);
+    TurnObjectEvent(5 * arg1 - 0x38 + arg0, arg2);
 }
 
 void sub_811C028(u32 arg0, u32 arg1, struct UnkStruct_Main0 *arg2)

src/scrcmd.c

@@ -1193,7 +1193,7 @@ bool8 ScrCmd_turnvobject(struct ScriptContext *ctx)
     u8 v1 = ScriptReadByte(ctx);
     u8 direction = ScriptReadByte(ctx);
 
-    sub_8069058(v1, direction);
+    TurnObjectEvent(v1, direction);
     return FALSE;
 }
 

src/vs_seeker.c

@@ -598,7 +598,7 @@ static void sub_810C3B8(u8 taskId)
         {
             if (sub_810CF04(i) == TRUE)
             {
-                if (gObjectEvents[i].mapobj_bit_1)
+                if (gObjectEvents[i].singleMovementActive)
                     return;
                 FreezeObjectEvent(&gObjectEvents[i]);
             }