diff --git a/docs/tutorial/advanced_control_flow.md b/docs/tutorial/advanced_control_flow.md
index 6353dc6842..ec9cd07269 100644
--- a/docs/tutorial/advanced_control_flow.md
+++ b/docs/tutorial/advanced_control_flow.md
@@ -46,7 +46,7 @@ static ColliderCylinderInitType1 D_80952BA0 = {
 
 static InitChainEntry D_80952BCC[] = {
     ICHAIN_U8(attentionRangeType, 2, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 500, ICHAIN_STOP),
 };
 
 
@@ -125,7 +125,7 @@ void EnMs_Update(Actor* thisx, PlayState* play) {
     EnMs* this = THIS;
 
     Actor_SetFocus(&this->actor, 20.0f);
-    this->actor.targetArrowOffset = 500.0f;
+    this->actor.lockOnArrowOffset = 500.0f;
     Actor_SetScale(&this->actor, 0.015f);
     SkelAnime_Update(&this->skelAnime);
     this->actionFunc(this, play);
diff --git a/docs/tutorial/beginning_decomp.md b/docs/tutorial/beginning_decomp.md
index eadc4dc44a..c1b9cb31fa 100644
--- a/docs/tutorial/beginning_decomp.md
+++ b/docs/tutorial/beginning_decomp.md
@@ -42,7 +42,7 @@ ActorInit En_Recepgirl_InitVars = {
 // static InitChainEntry sInitChain[] = {
 static InitChainEntry D_80C106C0[] = {
     ICHAIN_U8(attentionRangeType, 6, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1000, ICHAIN_STOP),
 };
 
 #endif
@@ -352,7 +352,7 @@ static void* D_80C106B0[4] = { (void*)0x600F8F0, (void*)0x600FCF0, (void*)0x6010
 // static InitChainEntry sInitChain[] = {
 static InitChainEntry D_80C106C0[] = {
     ICHAIN_U8(attentionRangeType, 6, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1000, ICHAIN_STOP),
 };
 
 static s32 D_80C106C8 = 0;
diff --git a/docs/tutorial/data.md b/docs/tutorial/data.md
index d5a764f110..512f659f8c 100644
--- a/docs/tutorial/data.md
+++ b/docs/tutorial/data.md
@@ -60,7 +60,7 @@ static void* D_80C106B0[4] = { (void*)0x600F8F0, (void*)0x600FCF0, (void*)0x6010
 // static InitChainEntry sInitChain[] = {
 static InitChainEntry D_80C106C0[] = {
     ICHAIN_U8(attentionRangeType, 6, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1000, ICHAIN_STOP),
 };
 
 static s32 D_80C106C8 = 0;
@@ -116,7 +116,7 @@ static void* D_80C106B0[4] = { (void*)0x600F8F0, (void*)0x600FCF0, (void*)0x6010
 // static InitChainEntry sInitChain[] = {
 static InitChainEntry D_80C106C0[] = {
     ICHAIN_U8(attentionRangeType, 6, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1000, ICHAIN_STOP),
 };
 
 static s32 D_80C106C8 = 0;
diff --git a/docs/tutorial/documenting.md b/docs/tutorial/documenting.md
index d307ce41ac..56ed9772c1 100644
--- a/docs/tutorial/documenting.md
+++ b/docs/tutorial/documenting.md
@@ -65,7 +65,7 @@ static void* D_80C106B0[4] = { object_bg_Tex_00F8F0, object_bg_Tex_00FCF0, objec
 // static InitChainEntry sInitChain[] = {
 static InitChainEntry D_80C106C0[] = {
     ICHAIN_U8(attentionRangeType, 6, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1000, ICHAIN_STOP),
 };
 
 static s32 D_80C106C8 = 0;
diff --git a/include/z64actor.h b/include/z64actor.h
index 7a0e9db536..0fe152edef 100644
--- a/include/z64actor.h
+++ b/include/z64actor.h
@@ -109,7 +109,7 @@ typedef struct Actor {
     /* 0x039 */ u8 audioFlags; // Another set of flags? Seems related to sfx or bgm
     /* 0x03C */ PosRot focus; // Target reticle focuses on this position. For player this represents head pos and rot
     /* 0x050 */ u16 sfxId; // Id of sound effect to play. Plays when value is set, then is cleared the following update cycle
-    /* 0x054 */ f32 targetArrowOffset; // Height offset of the target arrow relative to `focus` position
+    /* 0x054 */ f32 lockOnArrowOffset; // Height offset of the lock-on arrow relative to `focus` position
     /* 0x058 */ Vec3f scale; // Scale of the actor in each axis
     /* 0x064 */ Vec3f velocity; // Velocity of the actor in each axis
     /* 0x070 */ f32 speed; // Context dependent speed value. Can be used for XZ or XYZ depending on which move function is used
@@ -280,6 +280,21 @@ typedef enum {
 #define ACTORCTX_FLAG_6 (1 << 6)
 #define ACTORCTX_FLAG_7 (1 << 7)
 
+/**
+ * Attention System
+ *
+ * The Attention System's responsibility is to bring specific actors to the player's attention.
+ * This includes:
+ *     - Making Tatl fly over to certain actors of interest (can be lock-on actors, but may also not be)
+ *     - Displaying an arrow over an actor that can be locked onto
+ *     - Displaying a reticle over the current lock-on actor
+ *     - Playing enemy background music if a hostile actor is nearby
+ *     - Drift the camera towards an actor (unused)
+ *
+ * This system does not handle the actual lock-on implementation.
+ * That is the responsibility of Player via `player->focusActor` and the camera.
+ */
+
 // A set of 4 triangles which appear as a ring around an actor when locked-on
 typedef struct LockOnReticle {
     /* 0x00 */ Vec3f pos;
@@ -288,22 +303,22 @@ typedef struct LockOnReticle {
 } LockOnReticle; // size = 0x14
 
 typedef struct Attention {
-    /* 0x00 */ Vec3f fairyPos; // Used by Tatl to indicate a targetable actor or general hint
+    /* 0x00 */ Vec3f tatlHoverPos;  // Tatl's current hover position
     /* 0x0C */ Vec3f reticlePos; // Main reticle pos which each `LockOnReticle` instance can reference
-    /* 0x18 */ Color_RGBAf fairyInnerColor;
-    /* 0x28 */ Color_RGBAf fairyOuterColor;
-    /* 0x38 */ Actor* fairyActor;
+    /* 0x18 */ Color_RGBAf tatlInnerColor; // Tatl inner color, based on actor category
+    /* 0x28 */ Color_RGBAf tatlOuterColor; // Tatl outer color, based on actor category
+    /* 0x38 */ Actor* tatlHoverActor; // The actor that Tatl hovers over
     /* 0x3C */ Actor* reticleActor; // Actor to draw a reticle over
-    /* 0x40 */ f32 fairyMoveProgressFactor; // Controls Tatl so she can smootly transition to the target actor
+    /* 0x40 */ f32 tatlMoveProgressFactor; // Controls Tatl so she can smootly transition to an actor
     /* 0x44 */ f32 reticleRadius; // Main reticle radius value which each `LockOnReticle` instance can reference
     /* 0x48 */ s16 reticleFadeAlphaControl; // Set and fade the reticle alpha; Non-zero values control if it should draw
-    /* 0x4A */ u8 fairyActorCategory;
+    /* 0x4A */ u8 tatlHoverActorCategory; // Category of the actor Tatl is currently hovering over
     /* 0x4B */ u8 reticleSpinCounter; // Counts up when a reticle is active, used for the spinning animation
     /* 0x4C */ s8 curReticle; // Indexes lockOnReticles[]
     /* 0x50 */ LockOnReticle lockOnReticles[3]; // Multiple reticles are used for a motion-blur effect
-    /* 0x8C */ Actor* forcedTargetActor; // Never set to non-NULL
-    /* 0x90 */ Actor* bgmEnemy;
-    /* 0x94 */ Actor* arrowPointedActor;
+    /* 0x8C */ Actor* forcedLockOnActor; // Forces lock-on to this actor when set (never used in practice)
+    /* 0x90 */ Actor* bgmEnemy; // The nearest actor which can trigger enemy background music
+    /* 0x94 */ Actor* arrowHoverActor; // Actor to draw an arrow over
 } Attention; // size = 0x98
 
 // It is difficult to give each type a name because it is numerically based
@@ -325,8 +340,8 @@ typedef enum AttentionRangeType {
 } AttentionRangeType;
 
 typedef struct AttentionRangeParams {
-    /* 0x0 */ f32 rangeSq;
-    /* 0x4 */ f32 leashScale;
+    /* 0x0 */ f32 attentionRangeSq;
+    /* 0x4 */ f32 lockOnLeashScale;
 } AttentionRangeParams; // size = 0x8
 
 typedef struct {
@@ -448,9 +463,10 @@ typedef enum DoorLockType {
     /* 3 */ DOORLOCK_MAX
 } DoorLockType;
 
-// Actor is discoverable by the Attention System. This enables Navi to hover over the actor when it is in range.
+// Actor is discoverable by the Attention System. This enables Tatl to hover over the actor when it is in range.
 // The actor can also be locked onto (as long as `ACTOR_FLAG_LOCK_ON_DISABLED` is not set).
 #define ACTOR_FLAG_ATTENTION_ENABLED    (1 << 0)
+
 // Unused
 #define ACTOR_FLAG_2             (1 << 1)
 
@@ -469,8 +485,10 @@ typedef enum DoorLockType {
 #define ACTOR_FLAG_20            (1 << 5)
 // 
 #define ACTOR_FLAG_40            (1 << 6)
+
 // hidden or revealed by Lens of Truth (depending on room lensMode)
 #define ACTOR_FLAG_REACT_TO_LENS (1 << 7)
+
 // Signals that player has accepted an offer to talk to an actor
 // Player will retain this flag until the player is finished talking
 // Actor will retain this flag until `Actor_TalkOfferAccepted` is called or manually turned off by the actor
@@ -481,6 +499,7 @@ typedef enum DoorLockType {
 #define ACTOR_FLAG_400           (1 << 10)
 // 
 #define ACTOR_FLAG_800           (1 << 11)
+
 // Actor will not shake when a quake occurs
 #define ACTOR_FLAG_IGNORE_QUAKE  (1 << 12)
 // 
@@ -503,19 +522,25 @@ typedef enum DoorLockType {
 // With this flag Player talks directly to the actor with C-Up. It is expected that the resulting dialog should appear
 // to be coming from Tatl, even though she is not involved at all with this interaction.
 #define ACTOR_FLAG_TALK_WITH_C_UP (1 << 18)
-// 
-#define ACTOR_FLAG_80000         (1 << 19)
+
+// Allows for the attention system to refind the focus actor in the search for the next attention actor.
+// Also allows for the next lock-on actor to be the focus actor again.
+// When chosen as the next lock-on actor, this flag is unset.
+#define ACTOR_FLAG_FOCUS_ACTOR_REFINDABLE (1 << 19)
 // 
 #define ACTOR_FLAG_100000        (1 << 20)
 // 
 #define ACTOR_FLAG_200000        (1 << 21)
 // 
 #define ACTOR_FLAG_400000        (1 << 22)
+
 // When Player is carrying this actor, it can only be thrown, not dropped/placed.
 // Typically an actor can only be thrown when moving, but this allows an actor to be thrown when standing still.
 #define ACTOR_FLAG_THROW_ONLY    (1 << 23)
+
 // When colliding with Player's body AC collider, a "thump" sound will play indicating his body has been hit
 #define ACTOR_FLAG_SFX_FOR_PLAYER_BODY_HIT       (1 << 24)
+
 // Actor can update even if Player is currently using the ocarina.
 // Typically an actor will halt while the ocarina is active (depending on category).
 // This flag allows a given actor to be an exception.
@@ -532,8 +557,10 @@ typedef enum DoorLockType {
 #define ACTOR_FLAG_10000000      (1 << 28)
 // 
 #define ACTOR_FLAG_20000000      (1 << 29)
-// 
-#define ACTOR_FLAG_40000000      (1 << 30)
+
+// Camera will slowly drift to the actor while approaching it.
+// Uses the attention system but `ACTOR_FLAG_ATTENTION_ENABLED` is not required.
+#define ACTOR_FLAG_CAMERA_DRIFT_ENABLED (1 << 30)
 // 
 #define ACTOR_FLAG_80000000      (1 << 31)
 
@@ -698,7 +725,7 @@ extern s16 D_801AED48[8];
 extern Gfx D_801AEF88[];
 extern Gfx D_801AEFA0[];
 
-extern Actor* D_801ED920;
+extern Actor* gCameraDriftActor;
 
 void ActorShape_Init(ActorShape* actorShape, f32 yOffset, ActorShadowFunc shadowDraw, f32 shadowScale);
 void ActorShadow_DrawCircle(Actor* actor, struct Lights* lights, struct PlayState* play);
@@ -787,7 +814,7 @@ PosRot Actor_GetFocus(Actor* actor);
 PosRot Actor_GetWorld(Actor* actor);
 PosRot Actor_GetWorldPosShapeRot(Actor* actor);
 
-s32 Attention_OutsideLeashRange(Actor* actor, struct Player* player, s32 ignoreLeash);
+s32 Attention_ShouldReleaseLockOn(Actor* actor, struct Player* player, s32 ignoreLeash);
 s32 Actor_TalkOfferAccepted(Actor* actor, struct GameState* gameState);
 s32 Actor_OfferTalk(Actor* actor, struct PlayState* play, f32 radius);
 s32 Actor_OfferTalkNearColChkInfoCylinder(Actor* actor, struct PlayState* play);
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index a470420bfc..4d15beb510 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -14,21 +14,21 @@ FaultClient sActorFaultClient; // 2 funcs
 struct CollisionPoly* D_801ED8B0; // 1 func
 s32 D_801ED8B4;                   // 2 funcs
 
-struct Actor* sTargetableNearestActor;
-struct Actor* sTargetablePrioritizedActor;
-struct Actor* D_801ED8C0;
-struct Actor* D_801ED8C4;
+struct Actor* sNearestAttentionActor;
+struct Actor* sPrioritizedAttentionActor;
+struct Actor* sNearestCameraDriftActor;
+struct Actor* sPrioritizedCameraDriftActor;
 
-f32 sTargetableNearestActorDistSq;
+f32 sNearestAttentionActorDistSq;
 f32 sBgmEnemyDistSq;
-f32 D_801ED8D0;
-s32 sTargetablePrioritizedPriority;
-s32 D_801ED8D8;
-s16 sTargetPlayerRotY;
+f32 sNearestCameraDriftActorDistSq;
+s32 sHighestAttentionPriority;
+s32 sHighestCameraDriftPriority;
+s16 sAttentionPlayerRotY;
 
 Mtx sActorHiliteMtx;
 
-struct Actor* D_801ED920; // 2 funcs. 1 out of z_actor
+struct Actor* gCameraDriftActor;
 
 #include "z64actor.h"
 
@@ -64,8 +64,8 @@ struct Actor* D_801ED920; // 2 funcs. 1 out of z_actor
 void Actor_KillAllOnHalfDayChange(PlayState* play, ActorContext* actorCtx);
 Actor* Actor_SpawnEntry(ActorContext* actorCtx, ActorEntry* actorEntry, PlayState* play);
 Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, PlayState* play);
-void Attention_GetTargetActor(PlayState* play, ActorContext* actorCtx, Actor** targetableP, Actor** arg3,
-                              Player* player);
+void Attention_FindActor(PlayState* play, ActorContext* actorCtx, Actor** attentionActorP, Actor** cameraDriftActorP,
+                         Player* player);
 s32 func_800BA2FC(PlayState* play, Actor* actor, Vec3f* projectedPos, f32 projectedW);
 void Actor_AddToCategory(ActorContext* actorCtx, Actor* actor, u8 actorCategory);
 Actor* Actor_RemoveFromCategory(PlayState* play, ActorContext* actorCtx, Actor* actorToRemove);
@@ -428,21 +428,12 @@ void Actor_GetProjectedPos(PlayState* play, Vec3f* worldPos, Vec3f* projectedPos
     *invW = (*invW < 1.0f) ? 1.0f : (1.0f / *invW);
 }
 
-void Attention_SetReticlePos(Attention* attention, s32 reticleNum, f32 x, f32 y, f32 z) {
-    attention->lockOnReticles[reticleNum].pos.x = x;
-    attention->lockOnReticles[reticleNum].pos.y = y;
-    attention->lockOnReticles[reticleNum].pos.z = z;
+typedef struct AttentionColor {
+    /* 0x0 */ Color_RGBA8 primary;   // Used for Tatl's inner color, lock-on arrow, and lock-on reticle
+    /* 0x4 */ Color_RGBA8 secondary; // Used for Tatl's outer color
+} AttentionColor;                    // size = 0x8
 
-    attention->lockOnReticles[reticleNum].radius = attention->reticleRadius;
-}
-
-typedef struct {
-    /* 0x0 */ Color_RGBA8 inner;
-    /* 0x4 */ Color_RGBA8 outer;
-} TatlColor; // size = 0x8
-
-// For whatever reason it has an extra entry
-TatlColor sTatlColorList[] = {
+AttentionColor sAttentionColors[ACTORCAT_MAX + 1] = {
     { { 0, 255, 0, 255 }, { 0, 255, 0, 0 } },         // ACTORCAT_SWITCH
     { { 0, 255, 0, 255 }, { 0, 255, 0, 0 } },         // ACTORCAT_BG
     { { 255, 255, 230, 255 }, { 220, 160, 80, 0 } },  // ACTORCAT_PLAYER
@@ -455,59 +446,70 @@ TatlColor sTatlColorList[] = {
     { { 255, 255, 0, 255 }, { 200, 155, 0, 0 } },     // ACTORCAT_BOSS
     { { 0, 255, 0, 255 }, { 0, 255, 0, 0 } },         // ACTORCAT_DOOR
     { { 0, 255, 0, 255 }, { 0, 255, 0, 0 } },         // ACTORCAT_CHEST
-    { { 0, 255, 0, 255 }, { 0, 255, 0, 0 } },         // ACTORCAT_MAX
+    { { 0, 255, 0, 255 }, { 0, 255, 0, 0 } },         // unused extra entry
 };
 
+void Attention_SetReticlePos(Attention* attention, s32 reticleNum, f32 x, f32 y, f32 z) {
+    attention->lockOnReticles[reticleNum].pos.x = x;
+    attention->lockOnReticles[reticleNum].pos.y = y;
+    attention->lockOnReticles[reticleNum].pos.z = z;
+
+    attention->lockOnReticles[reticleNum].radius = attention->reticleRadius;
+}
+
 void Attention_InitReticle(Attention* attention, ActorType actorCategory, PlayState* play) {
-    TatlColor* tatlColorEntry;
-    s32 i;
     LockOnReticle* reticle;
+    AttentionColor* attentionColor = &sAttentionColors[actorCategory];
+    s32 i;
 
     Math_Vec3f_Copy(&attention->reticlePos, &play->view.eye);
-    attention->reticleFadeAlphaControl = 256;
-    tatlColorEntry = &sTatlColorList[actorCategory];
-    attention->reticleRadius = 500.0f;
 
-    reticle = attention->lockOnReticles;
+    attention->reticleRadius = 500.0f; // radius starts wide to zoom in on the actor
+    attention->reticleFadeAlphaControl = 256;
+
+    reticle = &attention->lockOnReticles[0];
+
     for (i = 0; i < ARRAY_COUNT(attention->lockOnReticles); i++, reticle++) {
         Attention_SetReticlePos(attention, i, 0.0f, 0.0f, 0.0f);
 
-        reticle->color.r = tatlColorEntry->inner.r;
-        reticle->color.g = tatlColorEntry->inner.g;
-        reticle->color.b = tatlColorEntry->inner.b;
+        reticle->color.r = attentionColor->primary.r;
+        reticle->color.g = attentionColor->primary.g;
+        reticle->color.b = attentionColor->primary.b;
     }
 }
 
-void Attention_SetFairyState(Attention* attention, Actor* actor, ActorType type, PlayState* play) {
-    attention->fairyPos.x = actor->focus.pos.x;
-    attention->fairyPos.y = actor->focus.pos.y + (actor->targetArrowOffset * actor->scale.y);
-    attention->fairyPos.z = actor->focus.pos.z;
+void Attention_SetTatlState(Attention* attention, Actor* actor, ActorType actorCategory, PlayState* play) {
+    AttentionColor* attentionColor = &sAttentionColors[actorCategory];
 
-    attention->fairyInnerColor.r = sTatlColorList[type].inner.r;
-    attention->fairyInnerColor.g = sTatlColorList[type].inner.g;
-    attention->fairyInnerColor.b = sTatlColorList[type].inner.b;
-    attention->fairyInnerColor.a = sTatlColorList[type].inner.a;
-    attention->fairyOuterColor.r = sTatlColorList[type].outer.r;
-    attention->fairyOuterColor.g = sTatlColorList[type].outer.g;
-    attention->fairyOuterColor.b = sTatlColorList[type].outer.b;
-    attention->fairyOuterColor.a = sTatlColorList[type].outer.a;
+    attention->tatlHoverPos.x = actor->focus.pos.x;
+    attention->tatlHoverPos.y = actor->focus.pos.y + (actor->lockOnArrowOffset * actor->scale.y);
+    attention->tatlHoverPos.z = actor->focus.pos.z;
+
+    attention->tatlInnerColor.r = attentionColor->primary.r;
+    attention->tatlInnerColor.g = attentionColor->primary.g;
+    attention->tatlInnerColor.b = attentionColor->primary.b;
+    attention->tatlInnerColor.a = attentionColor->primary.a;
+
+    attention->tatlOuterColor.r = attentionColor->secondary.r;
+    attention->tatlOuterColor.g = attentionColor->secondary.g;
+    attention->tatlOuterColor.b = attentionColor->secondary.b;
+    attention->tatlOuterColor.a = attentionColor->secondary.a;
 }
 
 void Attention_Init(Attention* attention, Actor* actor, PlayState* play) {
-    attention->bgmEnemy = NULL;
-    attention->forcedTargetActor = NULL;
-    attention->reticleActor = NULL;
-    attention->fairyActor = NULL;
+    attention->tatlHoverActor = attention->reticleActor = attention->forcedLockOnActor = attention->bgmEnemy = NULL;
+
     attention->reticleSpinCounter = 0;
     attention->curReticle = 0;
-    attention->fairyMoveProgressFactor = 0.0f;
-    Attention_SetFairyState(attention, actor, actor->category, play);
+    attention->tatlMoveProgressFactor = 0.0f;
+
+    Attention_SetTatlState(attention, actor, actor->category, play);
     Attention_InitReticle(attention, actor->category, play);
 }
 
 void Attention_Draw(Attention* attention, PlayState* play) {
     Player* player = GET_PLAYER(play);
-    Actor* actor;
+    Actor* actor; // used for both the reticle actor and arrow hover actor
 
     if (player->stateFlags1 & (PLAYER_STATE1_2 | PLAYER_STATE1_40 | PLAYER_STATE1_80 | PLAYER_STATE1_200 |
                                PLAYER_STATE1_400 | PLAYER_STATE1_10000000 | PLAYER_STATE1_20000000)) {
@@ -521,7 +523,7 @@ void Attention_Draw(Attention* attention, PlayState* play) {
     if (attention->reticleFadeAlphaControl != 0) {
         LockOnReticle* reticle;
         s16 alpha = 255;
-        f32 projectdPosScale = 1.0f;
+        f32 projectedPosScale = 1.0f;
         Vec3f projectedPos;
         s32 numReticles;
         f32 invW;
@@ -540,7 +542,7 @@ void Attention_Draw(Attention* attention, PlayState* play) {
 
         if (actor != NULL) {
             Math_Vec3f_Copy(&attention->reticlePos, &actor->focus.pos);
-            projectdPosScale = (500.0f - attention->reticleRadius) / 420.0f;
+            projectedPosScale = (500.0f - attention->reticleRadius) / 420.0f;
         } else {
             // Not locked on, start fading out
             attention->reticleFadeAlphaControl -= 120;
@@ -556,13 +558,13 @@ void Attention_Draw(Attention* attention, PlayState* play) {
 
         Actor_GetProjectedPos(play, &attention->reticlePos, &projectedPos, &invW);
 
-        projectedPos.x = ((SCREEN_WIDTH / 2) * (projectedPos.x * invW)) * projectdPosScale;
+        projectedPos.x = ((SCREEN_WIDTH / 2) * (projectedPos.x * invW)) * projectedPosScale;
         projectedPos.x = CLAMP(projectedPos.x, -SCREEN_WIDTH, SCREEN_WIDTH);
 
-        projectedPos.y = ((SCREEN_HEIGHT / 2) * (projectedPos.y * invW)) * projectdPosScale;
+        projectedPos.y = ((SCREEN_HEIGHT / 2) * (projectedPos.y * invW)) * projectedPosScale;
         projectedPos.y = CLAMP(projectedPos.y, -SCREEN_HEIGHT, SCREEN_HEIGHT);
 
-        projectedPos.z *= projectdPosScale;
+        projectedPos.z *= projectedPosScale;
 
         attention->curReticle--;
 
@@ -616,19 +618,20 @@ void Attention_Draw(Attention* attention, PlayState* play) {
         }
     }
 
-    actor = attention->arrowPointedActor;
+    actor = attention->arrowHoverActor;
 
     if ((actor != NULL) && !(actor->flags & ACTOR_FLAG_LOCK_ON_DISABLED)) {
-        TatlColor* color = &sTatlColorList[actor->category];
+        AttentionColor* attentionColor = &sAttentionColors[actor->category];
 
         POLY_XLU_DISP = Gfx_SetupDL(POLY_XLU_DISP, SETUPDL_7);
 
-        Matrix_Translate(actor->focus.pos.x, actor->focus.pos.y + (actor->targetArrowOffset * actor->scale.y) + 17.0f,
+        Matrix_Translate(actor->focus.pos.x, actor->focus.pos.y + (actor->lockOnArrowOffset * actor->scale.y) + 17.0f,
                          actor->focus.pos.z, MTXMODE_NEW);
         Matrix_RotateYS(play->gameplayFrames * 0xBB8, MTXMODE_APPLY);
         Matrix_Scale((iREG(27) + 35) / 1000.0f, (iREG(28) + 60) / 1000.0f, (iREG(29) + 50) / 1000.0f, MTXMODE_APPLY);
 
-        gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, color->inner.r, color->inner.g, color->inner.b, 255);
+        gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, attentionColor->primary.r, attentionColor->primary.g,
+                        attentionColor->primary.b, 255);
         MATRIX_FINALIZE_AND_LOAD(POLY_XLU_DISP++, play->state.gfxCtx);
         gSPDisplayList(POLY_XLU_DISP++, gLockOnArrowDL);
     }
@@ -638,24 +641,32 @@ void Attention_Draw(Attention* attention, PlayState* play) {
 
 void Attention_Update(Attention* attention, Player* player, Actor* playerFocusActor, PlayState* play) {
     s32 pad;
-    Actor* actor = NULL;
+    Actor* actor; // used for both the Tatl hover actor and reticle actor
     s32 category;
     Vec3f projectedPos;
     f32 invW;
 
-    // If currently not locked on to an actor and not pressing down on the analog stick then try to find a targetable
-    // actor
+    actor = NULL;
+
     if ((player->focusActor != NULL) && (player->unk_AE3[player->unk_ADE] == 2)) {
-        attention->arrowPointedActor = NULL;
+        // Holding backward on the control stick prevents an arrow appearing over the next lock-on actor.
+        // This helps escape a lock-on loop when using Switch Targeting, but note that this still works for
+        // Hold Targeting as well.
+        attention->arrowHoverActor = NULL;
     } else {
-        Attention_GetTargetActor(play, &play->actorCtx, &actor, &D_801ED920, player);
-        attention->arrowPointedActor = actor;
+        // Find the next attention actor so Tatl and an arrow can hover over it (if applicable)
+        Attention_FindActor(play, &play->actorCtx, &actor, &gCameraDriftActor, player);
+        attention->arrowHoverActor = actor;
     }
 
-    if (attention->forcedTargetActor != NULL) {
-        actor = attention->forcedTargetActor;
-        attention->forcedTargetActor = NULL;
+    if (attention->forcedLockOnActor != NULL) {
+        // This lock-on actor takes precedence over anything else
+        // (this feature is never used in practice)
+        actor = attention->forcedLockOnActor;
+        attention->forcedLockOnActor = NULL;
     } else if (playerFocusActor != NULL) {
+        // Stay locked-on to the same actor, if there is one.
+        // This also makes Tatl fly over to the current focus actor, if there is one.
         actor = playerFocusActor;
     }
 
@@ -665,77 +676,94 @@ void Attention_Update(Attention* attention, Player* player, Actor* playerFocusAc
         category = player->actor.category;
     }
 
-    if ((actor != attention->fairyActor) || (category != attention->fairyActorCategory)) {
-        attention->fairyActor = actor;
-        attention->fairyActorCategory = category;
-        attention->fairyMoveProgressFactor = 1.0f;
+    if ((actor != attention->tatlHoverActor) || (category != attention->tatlHoverActorCategory)) {
+        // Set Tatl to hover over a new actor
+        attention->tatlHoverActor = actor;
+        attention->tatlHoverActorCategory = category;
+        attention->tatlMoveProgressFactor = 1.0f;
     }
 
     if (actor == NULL) {
+        // Setting the actor to Player will make Tatl return to him
         actor = &player->actor;
     }
 
-    if (!Math_StepToF(&attention->fairyMoveProgressFactor, 0.0f, 0.25f)) {
-        f32 fairyMoveScale = 0.25f / attention->fairyMoveProgressFactor;
-        f32 x = actor->focus.pos.x - attention->fairyPos.x;
-        f32 y = (actor->focus.pos.y + (actor->targetArrowOffset * actor->scale.y)) - attention->fairyPos.y;
-        f32 z = actor->focus.pos.z - attention->fairyPos.z;
+    if (!Math_StepToF(&attention->tatlMoveProgressFactor, 0.0f, 0.25f)) {
+        f32 moveScale = 0.25f / attention->tatlMoveProgressFactor;
+        f32 x = actor->focus.pos.x - attention->tatlHoverPos.x;
+        f32 y = (actor->focus.pos.y + (actor->lockOnArrowOffset * actor->scale.y)) - attention->tatlHoverPos.y;
+        f32 z = actor->focus.pos.z - attention->tatlHoverPos.z;
 
-        attention->fairyPos.x += x * fairyMoveScale;
-        attention->fairyPos.y += y * fairyMoveScale;
-        attention->fairyPos.z += z * fairyMoveScale;
+        attention->tatlHoverPos.x += x * moveScale;
+        attention->tatlHoverPos.y += y * moveScale;
+        attention->tatlHoverPos.z += z * moveScale;
     } else {
-        Attention_SetFairyState(attention, actor, category, play);
+        // Set Tatl pos and color after reaching destination
+        Attention_SetTatlState(attention, actor, category, play);
     }
 
     if ((playerFocusActor != NULL) && (attention->reticleSpinCounter == 0)) {
         Actor_GetProjectedPos(play, &playerFocusActor->focus.pos, &projectedPos, &invW);
+
         if ((projectedPos.z <= 0.0f) || (fabsf(projectedPos.x * invW) >= 1.0f) ||
             (fabsf(projectedPos.y * invW) >= 1.0f)) {
+            // Release the reticle if the actor is off screen.
+            // It is possible to move far enough away from an actor that it goes off screen, despite being
+            // locked onto it. In this case the reticle will release, but the lock-on will remain
+            // because Player is still updating focusActor.
+            // It is unclear if this is intentional, or if it is a bug and the lock-on as a whole is supposed
+            // to release.
             playerFocusActor = NULL;
         }
     }
 
     if (playerFocusActor != NULL) {
         if (playerFocusActor != attention->reticleActor) {
-            s32 sfxId;
+            s32 lockOnSfxId;
 
-            // Lock On entries need to be re-initialized when changing the targeted actor
+            // Set up a new reticle
             Attention_InitReticle(attention, playerFocusActor->category, play);
-
             attention->reticleActor = playerFocusActor;
 
             if (playerFocusActor->id == ACTOR_EN_BOOM) {
-                // Avoid drawing the lock on triangles on a zora boomerang
+                // Don't draw the reticle when locked onto the zora fin boomerang.
+                // Note that it isn't possible to lock onto the boomerang, so this code doesn't do anything.
+                // This implies that the boomerang camera lock may have been implemented with Z-Targeting at one point,
+                // but was eventually implemented as its own camera mode instead.
                 attention->reticleFadeAlphaControl = 0;
             }
 
-            sfxId = CHECK_FLAG_ALL(playerFocusActor->flags, ACTOR_FLAG_ATTENTION_ENABLED | ACTOR_FLAG_HOSTILE)
-                        ? NA_SE_SY_LOCK_ON
-                        : NA_SE_SY_LOCK_ON_HUMAN;
-            Audio_PlaySfx(sfxId);
+            lockOnSfxId = CHECK_FLAG_ALL(playerFocusActor->flags, ACTOR_FLAG_ATTENTION_ENABLED | ACTOR_FLAG_HOSTILE)
+                              ? NA_SE_SY_LOCK_ON
+                              : NA_SE_SY_LOCK_ON_HUMAN;
+            Audio_PlaySfx(lockOnSfxId);
         }
 
+        // Update reticle
+
         attention->reticlePos.x = playerFocusActor->world.pos.x;
         attention->reticlePos.y =
             playerFocusActor->world.pos.y - (playerFocusActor->shape.yOffset * playerFocusActor->scale.y);
         attention->reticlePos.z = playerFocusActor->world.pos.z;
 
         if (attention->reticleSpinCounter == 0) {
-            f32 lockOnStep = (500.0f - attention->reticleRadius) * 3.0f;
+            f32 step = (500.0f - attention->reticleRadius) * 3.0f;
+            f32 reticleZoomStep = CLAMP(step, 30.0f, 100.0f);
 
-            lockOnStep = CLAMP(lockOnStep, 30.0f, 100.0f);
-
-            if (Math_StepToF(&attention->reticleRadius, 80.0f, lockOnStep)) {
+            if (Math_StepToF(&attention->reticleRadius, 80.0f, reticleZoomStep)) {
+                // Non-zero counter indicates the reticle is done zooming in
                 attention->reticleSpinCounter++;
             }
         } else {
-            // 0x80 is or'd to avoid getting this value be set to zero
+            // Finished zooming in, spin the reticle around the lock-on actor
+
+            // 0x80 is or'd to avoid a value of zero.
             // This rotation value gets multiplied by 0x200, which multiplied by 0x80 gives a full turn (0x10000)
             attention->reticleSpinCounter = (attention->reticleSpinCounter + 3) | 0x80;
             attention->reticleRadius = 120.0f;
         }
     } else {
+        // Expand the radius quickly as the reticle is released
         attention->reticleActor = NULL;
         Math_StepToF(&attention->reticleRadius, 500.0f, 80.0f);
     }
@@ -1856,32 +1884,32 @@ PosRot Actor_GetWorldPosShapeRot(Actor* actor) {
 
 /**
  * Returns the squared xyz distance from the actor to Player.
- *
- * This distance will be adjusted smaller if Player is already targeting an actor. The more Player is facing the actor,
- * the smaller the distance is adjusted.
+ * This distance will be weighted if Player is already locked onto another actor.
  */
-f32 Attention_GetAdjustedDistSq(Actor* actor, Player* player, s16 playerShapeYaw) {
+f32 Attention_WeightedDistToPlayerSq(Actor* actor, Player* player, s16 playerShapeYaw) {
     f32 adjDistSq;
-    s16 yawDiff;
-
-    // The yaw, with player as the origin, from where player is facing to where the actor is positioned
-    yawDiff = ABS_ALT(BINANG_SUB(BINANG_SUB(actor->yawTowardsPlayer, 0x8000), playerShapeYaw));
+    s16 yawDiffAbs = ABS_ALT(BINANG_SUB(BINANG_SUB(actor->yawTowardsPlayer, 0x8000), playerShapeYaw));
 
     if (player->focusActor != NULL) {
-        if ((yawDiff > 0x4000) || (actor->flags & ACTOR_FLAG_LOCK_ON_DISABLED)) {
+        if ((yawDiffAbs > 0x4000) || (actor->flags & ACTOR_FLAG_LOCK_ON_DISABLED)) {
             return FLT_MAX;
         }
 
-        // Linear scaling, yaw being 90 degree means it will return the original distance, 0 degree will adjust to 60%
-        // of the distance
+        // The distance returned is scaled down as the player faces more toward the actor.
+        // At 90 degrees, 100% of the original distance will be returned.
+        // This scales down linearly to 60% when facing 0 degrees away.
         adjDistSq =
-            actor->xyzDistToPlayerSq - ((actor->xyzDistToPlayerSq * 0.8f) * ((0x4000 - yawDiff) * (1.0f / 0x8000)));
+            actor->xyzDistToPlayerSq - ((actor->xyzDistToPlayerSq * 0.8f) * ((0x4000 - yawDiffAbs) * (1.0f / 0x8000)));
+
         return adjDistSq;
     }
 
-    if (yawDiff > (0x10000 / 6)) {
+    // Player has to be facing less than ~60 degrees away from the actor
+    if (yawDiffAbs > (0x10000 / 6)) {
         return FLT_MAX;
     }
+
+    // Unweighted distSq
     return actor->xyzDistToPlayerSq;
 }
 
@@ -1903,37 +1931,46 @@ AttentionRangeParams gAttentionRanges[ATTENTION_RANGE_MAX] = {
 };
 
 /**
- * Checks if an actor at distance `distSq` is inside the range specified by its attentionRangeType
+ * Checks if an actor at `distSq` is inside the range specified by its `attentionRangeType`.
+ *
+ * Note that this gets used for both the attention range check and for the lock-on leash range check.
+ * Despite how the data is presented in `gAttentionRanges`, the leash range is stored as a scale factor value.
+ * When checking the leash range, this scale factor is applied to the input distance and checked against
+ * the base `attentionRangeSq` value, which was used to initiate the lock-on in the first place.
  */
-s32 Attention_IsActorInRange(Actor* actor, f32 distSq) {
-    return distSq < gAttentionRanges[actor->attentionRangeType].rangeSq;
+s32 Attention_ActorIsInRange(Actor* actor, f32 distSq) {
+    return distSq < gAttentionRanges[actor->attentionRangeType].attentionRangeSq;
 }
 
 /**
- * Returns true if the actor is outside the leash distance to player.
+ * Returns true if an actor lock-on should be released.
+ * This function does not actually release the lock-on, as that is Player's responsibility.
+ *
+ * If an actor's update function is NULL or `ACTOR_FLAG_ATTENTION_ENABLED` is unset, the lock-on should be released.
+ *
+ * There is also a check for Player exceeding the lock-on leash distance.
+ * Note that this check will be ignored if `ignoreLeash` is true.
  *
- * Passing true to ignoreLeash avoids the distance and yaw checks, and considers the actor inside the leash distance.
  */
-s32 Attention_OutsideLeashRange(Actor* actor, Player* player, s32 ignoreLeash) {
+s32 Attention_ShouldReleaseLockOn(Actor* actor, Player* player, s32 ignoreLeash) {
     if ((actor->update == NULL) || !(actor->flags & ACTOR_FLAG_ATTENTION_ENABLED) ||
         (actor->flags & ACTOR_FLAG_LOCK_ON_DISABLED)) {
         return true;
     }
 
     if (!ignoreLeash) {
-        s16 yawDiff;
+        s16 yawDiffAbs = ABS_ALT(BINANG_SUB(BINANG_SUB(actor->yawTowardsPlayer, 0x8000), player->actor.shape.rot.y));
         f32 distSq;
 
-        // The yaw, with player as the origin, from where player is facing to where the actor is positioned
-        yawDiff = ABS_ALT(BINANG_SUB(BINANG_SUB(actor->yawTowardsPlayer, 0x8000), player->actor.shape.rot.y));
-
-        if ((player->focusActor == NULL) && (yawDiff > (0x10000 / 6))) {
+        if ((player->focusActor == NULL) && (yawDiffAbs > (0x10000 / 6))) {
+            // This function is only called (and is only relevant) when `player->focusActor != NULL`.
+            // This is unreachable.
             distSq = FLT_MAX;
         } else {
             distSq = actor->xyzDistToPlayerSq;
         }
 
-        return !Attention_IsActorInRange(actor, gAttentionRanges[actor->attentionRangeType].leashScale * distSq);
+        return !Attention_ActorIsInRange(actor, gAttentionRanges[actor->attentionRangeType].lockOnLeashScale * distSq);
     }
 
     return false;
@@ -3493,12 +3530,12 @@ Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, PlayState* play) {
         Camera_ChangeMode(Play_GetCamera(play, Play_GetActiveCamId(play)), CAM_MODE_NORMAL);
     }
 
-    if (actor == actorCtx->attention.fairyActor) {
-        actorCtx->attention.fairyActor = NULL;
+    if (actor == actorCtx->attention.tatlHoverActor) {
+        actorCtx->attention.tatlHoverActor = NULL;
     }
 
-    if (actor == actorCtx->attention.forcedTargetActor) {
-        actorCtx->attention.forcedTargetActor = NULL;
+    if (actor == actorCtx->attention.forcedLockOnActor) {
+        actorCtx->attention.forcedLockOnActor = NULL;
     }
 
     if (actor == actorCtx->attention.bgmEnemy) {
@@ -3519,61 +3556,57 @@ Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, PlayState* play) {
     return newHead;
 }
 
-bool Attention_InTargetableScreenRegion(PlayState* play, Actor* actor) {
-    s16 screenPosX;
-    s16 screenPosY;
+/**
+ * Checks that an actor is on-screen enough to be considered an attention actor.
+ *
+ * Note that the screen bounds checks are larger than the actual screen region
+ * to give room for error.
+ */
+bool Attention_ActorOnScreen(PlayState* play, Actor* actor) {
+    s16 x;
+    s16 y;
 
-    Actor_GetScreenPos(play, actor, &screenPosX, &screenPosY);
+    Actor_GetScreenPos(play, actor, &x, &y);
 
-    return (screenPosX > -20) && (screenPosX < gScreenWidth + 20) && (screenPosY > -160) &&
-           (screenPosY < gScreenHeight + 160);
+#define X_LEEWAY 20
+#define Y_LEEWAY 160
+
+    return (x > (0 - X_LEEWAY)) && (x < (gScreenWidth + X_LEEWAY)) && (y > (0 - Y_LEEWAY)) &&
+           (y < (gScreenHeight + Y_LEEWAY));
 }
 
 /**
- * Search for targetable actors of the `actorCategory` category.
+ * Search for attention actors or camera drift actors within the specified category.
  *
- * Looks for the actor of said category with higher targetPriority and the one that is nearest to player. This actor
- * must be within the range (relative to player) speicified by its attentionRangeType.
+ * To be considered an attention actor the actor needs to:
+ * - Have a non-NULL update function (still active)
+ * - Not be player (this is technically a redundant check because the PLAYER category is never searched)
+ * - Have `ACTOR_FLAG_ATTENTION_ENABLED` or `ACTOR_FLAG_FOCUS_ACTOR_REFINDABLE` set
+ * - Not be the current focus actor unless `ACTOR_FLAG_FOCUS_ACTOR_REFINDABLE` is set
+ * - Be the closest attention actor found so far
+ * - Be within range, specified by attentionRangeType
+ * - Be roughly on-screen
+ * - Not be blocked by a surface
  *
- * The actor must be on-screen
- *
- * The highest priority actor is stored in `sTargetablePrioritizedActor`, while the nearest actor is stored in
- * `sTargetableNearestActor`. The higher priority / smaller distance of those actors are stored in
- * `sTargetablePrioritizedPriority` and `sTargetableNearestActorDistSq`.
- *
- * There is not much info to infer anything about ACTOR_FLAG_40000000, D_801ED8C4/D_801ED8C0, D_801ED8D8/D_801ED8D0.
- * All appear unused in any meaningful way.
- *
- * For an actor to be taken in consideration by this function it needs:
- * - Non-NULL update function (maybe obvious?)
- * - Not be Player itself.
- * - It must be targetable or ACTOR_FLAG_40000000
- * - Not be the already targeted actor, unless it has the ACTOR_FLAG_80000 flag
- * - Be withing the range specified by its attentionRangeType.
- * - It must be on-screen (within a margin)
- * - Must not be blocked by a surface (?)
- *
- * This function also checks for the nearest enemy actor, which allows determining if enemy background music should be
- * played. This actor is stored in `attention.bgmEnemy` and its distance is stored in `sBgmEnemyDistSq`
+ * If an actor has a priority value set and the value is the lowest found so far, it will be set as the prioritized
+ * attention actor. Otherwise, it is set as the nearest attention actor or camera drift actor.
  *
  * This function is expected to be called with almost every actor category in each cycle. On a new cycle its global
- * variables must be reset by the caller, otherwise the information of the previous cycle will be retained on this one.
+ * variables must be reset by the caller, otherwise the information of the previous cycle will be retained.
  */
-void Attention_FindTargetableActorForCategory(PlayState* play, ActorContext* actorCtx, Player* player,
-                                              ActorType actorCategory) {
+void Attention_FindActorInCategory(PlayState* play, ActorContext* actorCtx, Player* player, ActorType actorCategory) {
     f32 distSq;
     Actor* actor = actorCtx->actorLists[actorCategory].first;
     Actor* playerFocusActor = player->focusActor;
-    s32 isNearestTargetableActor;
-    s32 phi_s2_2;
+    s32 isNearestAttentionActor;
+    s32 isNearestCameraDriftActor;
 
     for (; actor != NULL; actor = actor->next) {
         if ((actor->update == NULL) || ((Player*)actor == player)) {
             continue;
         }
 
-        // Actor must be at least either targetable or ACTOR_FLAG_40000000
-        if (!(actor->flags & (ACTOR_FLAG_ATTENTION_ENABLED | ACTOR_FLAG_40000000))) {
+        if (!(actor->flags & (ACTOR_FLAG_ATTENTION_ENABLED | ACTOR_FLAG_CAMERA_DRIFT_ENABLED))) {
             continue;
         }
 
@@ -3586,107 +3619,110 @@ void Attention_FindTargetableActorForCategory(PlayState* play, ActorContext* act
             }
         }
 
-        // If this actor is the currently targeted one, then ignore it unless it has the ACTOR_FLAG_80000 flag
-        if ((actor == playerFocusActor) && !(actor->flags & ACTOR_FLAG_80000)) {
+        // Ignore the current focus actor unless it is refindable
+        if ((actor == playerFocusActor) && !(actor->flags & ACTOR_FLAG_FOCUS_ACTOR_REFINDABLE)) {
             continue;
         }
 
-        distSq = Attention_GetAdjustedDistSq(actor, player, sTargetPlayerRotY);
+        distSq = Attention_WeightedDistToPlayerSq(actor, player, sAttentionPlayerRotY);
 
-        isNearestTargetableActor =
-            (actor->flags & ACTOR_FLAG_ATTENTION_ENABLED) && (distSq < sTargetableNearestActorDistSq);
-        phi_s2_2 = (actor->flags & ACTOR_FLAG_40000000) && (distSq < D_801ED8D0);
+        isNearestAttentionActor =
+            (actor->flags & ACTOR_FLAG_ATTENTION_ENABLED) && (distSq < sNearestAttentionActorDistSq);
 
-        if (!isNearestTargetableActor && !phi_s2_2) {
+        isNearestCameraDriftActor =
+            (actor->flags & ACTOR_FLAG_CAMERA_DRIFT_ENABLED) && (distSq < sNearestCameraDriftActorDistSq);
+
+        if (!isNearestAttentionActor && !isNearestCameraDriftActor) {
             continue;
         }
 
-        if (Attention_IsActorInRange(actor, distSq) && Attention_InTargetableScreenRegion(play, actor)) {
+        if (Attention_ActorIsInRange(actor, distSq) && Attention_ActorOnScreen(play, actor)) {
             CollisionPoly* poly;
             s32 bgId;
-            Vec3f posResult;
+            Vec3f lineTestResultPos;
 
-            if (BgCheck_CameraLineTest1(&play->colCtx, &player->actor.focus.pos, &actor->focus.pos, &posResult, &poly,
-                                        true, true, true, true, &bgId)) {
+            if (BgCheck_CameraLineTest1(&play->colCtx, &player->actor.focus.pos, &actor->focus.pos, &lineTestResultPos,
+                                        &poly, true, true, true, true, &bgId)) {
                 if (!SurfaceType_IsIgnoredByProjectiles(&play->colCtx, poly, bgId)) {
                     continue;
                 }
             }
 
             if (actor->targetPriority != 0) {
-                if (isNearestTargetableActor && (actor->targetPriority < sTargetablePrioritizedPriority)) {
-                    sTargetablePrioritizedActor = actor;
-                    sTargetablePrioritizedPriority = actor->targetPriority;
+                if (isNearestAttentionActor && (actor->targetPriority < sHighestAttentionPriority)) {
+                    sPrioritizedAttentionActor = actor;
+                    sHighestAttentionPriority = actor->targetPriority;
                 }
-                if (phi_s2_2 && (actor->targetPriority < D_801ED8D8)) {
-                    D_801ED8C4 = actor;
-                    D_801ED8D8 = actor->targetPriority;
+                if (isNearestCameraDriftActor && (actor->targetPriority < sHighestCameraDriftPriority)) {
+                    sPrioritizedCameraDriftActor = actor;
+                    sHighestCameraDriftPriority = actor->targetPriority;
                 }
             } else {
-                if (isNearestTargetableActor) {
-                    sTargetableNearestActor = actor;
-                    sTargetableNearestActorDistSq = distSq;
+                if (isNearestAttentionActor) {
+                    sNearestAttentionActor = actor;
+                    sNearestAttentionActorDistSq = distSq;
                 }
-                if (phi_s2_2) {
-                    D_801ED8C0 = actor;
-                    D_801ED8D0 = distSq;
+                if (isNearestCameraDriftActor) {
+                    sNearestCameraDriftActor = actor;
+                    sNearestCameraDriftActorDistSq = distSq;
                 }
             }
         }
     }
 }
 
-u8 sTargetableActorCategories[] = {
+u8 sAttentionCategorySearchOrder[] = {
     ACTORCAT_BOSS,  ACTORCAT_ENEMY,  ACTORCAT_BG,   ACTORCAT_EXPLOSIVES, ACTORCAT_NPC,  ACTORCAT_ITEMACTION,
     ACTORCAT_CHEST, ACTORCAT_SWITCH, ACTORCAT_PROP, ACTORCAT_MISC,       ACTORCAT_DOOR, ACTORCAT_SWITCH,
 };
 
 /**
- * Search for the nearest targetable actor.
+ * Search for the nearest attention actor and camera drift actor by iterating through most actor categories.
+ * See `Attention_FindActorInCategory` for more details on search criteria.
  *
- * The specific criteria is specified in Attention_FindTargetableActorForCategory.
- *
- * The actor found is stored in the targetableP parameter. It may be NULL if no actor that fulfills the criteria is
- * found.
+ * The attention actor found is stored in the `attentionActorP` parameter, while the camera drift actor is stored in
+ * `cameraDriftActorP` They may be NULL if no actor that fulfills the criteria is found.
  */
-void Attention_GetTargetActor(PlayState* play, ActorContext* actorCtx, Actor** targetableP, Actor** arg3,
-                              Player* player) {
-    u8* actorCategories;
+void Attention_FindActor(PlayState* play, ActorContext* actorCtx, Actor** attentionActorP, Actor** cameraDriftActorP,
+                         Player* player) {
+    u8* category;
     s32 i;
 
-    sTargetableNearestActor = sTargetablePrioritizedActor = D_801ED8C0 = D_801ED8C4 = NULL;
-    sTargetableNearestActorDistSq = D_801ED8D0 = sBgmEnemyDistSq = FLT_MAX;
-    sTargetablePrioritizedPriority = D_801ED8D8 = INT32_MAX;
+    sNearestAttentionActor = sPrioritizedAttentionActor = sNearestCameraDriftActor = sPrioritizedCameraDriftActor =
+        NULL;
+    sNearestAttentionActorDistSq = sNearestCameraDriftActorDistSq = sBgmEnemyDistSq = FLT_MAX;
+    sHighestAttentionPriority = sHighestCameraDriftPriority = INT32_MAX;
 
     actorCtx->attention.bgmEnemy = NULL;
-    sTargetPlayerRotY = player->actor.shape.rot.y;
+    sAttentionPlayerRotY = player->actor.shape.rot.y;
 
-    actorCategories = sTargetableActorCategories;
+    category = sAttentionCategorySearchOrder;
 
-    // Try to search for a targetable actor that's a Boss, Enemy or Bg first
+    // Search the first 3 actor categories first for an attention actor
+    // These are Boss, Enemy, and Bg, in order.
     for (i = 0; i < 3; i++) {
-        Attention_FindTargetableActorForCategory(play, actorCtx, player, *actorCategories);
-        actorCategories++;
+        Attention_FindActorInCategory(play, actorCtx, player, *category);
+        category++;
     }
 
-    // If no actor in the above categories was found then try to search for one in every other category
-    if (sTargetableNearestActor == NULL) {
-        for (; i < ARRAY_COUNT(sTargetableActorCategories); i++) {
-            Attention_FindTargetableActorForCategory(play, actorCtx, player, *actorCategories);
-            actorCategories++;
+    // If no actor in the above categories was found, then try searching in the remaining categories
+    if (sNearestAttentionActor == NULL) {
+        for (; i < ARRAY_COUNT(sAttentionCategorySearchOrder); i++) {
+            Attention_FindActorInCategory(play, actorCtx, player, *category);
+            category++;
         }
     }
 
-    if (sTargetableNearestActor == NULL) {
-        *targetableP = sTargetablePrioritizedActor;
+    if (sNearestAttentionActor == NULL) {
+        *attentionActorP = sPrioritizedAttentionActor;
     } else {
-        *targetableP = sTargetableNearestActor;
+        *attentionActorP = sNearestAttentionActor;
     }
 
-    if (D_801ED8C0 == NULL) {
-        *arg3 = D_801ED8C4;
+    if (sNearestCameraDriftActor == NULL) {
+        *cameraDriftActorP = sPrioritizedCameraDriftActor;
     } else {
-        *arg3 = D_801ED8C0;
+        *cameraDriftActorP = sNearestCameraDriftActor;
     }
 }
 
diff --git a/src/code/z_camera.c b/src/code/z_camera.c
index ab9252ad94..b2570386fb 100644
--- a/src/code/z_camera.c
+++ b/src/code/z_camera.c
@@ -1274,9 +1274,12 @@ f32 Camera_CalcSlopeYAdj(Vec3f* floorNorm, s16 playerYRot, s16 eyeAtYaw, f32 adj
     return (Camera_fabsf(tmp) * adjAmt) * Math_CosS(playerYRot - eyeAtYaw);
 }
 
-f32 func_800CD6CC(Actor* actor) {
-    return sqrtf(gAttentionRanges[actor->attentionRangeType].rangeSq /
-                 gAttentionRanges[actor->attentionRangeType].leashScale);
+/**
+ * Gets the distance that the attention actor is in range.
+ */
+f32 Camera_GetAttentionActorRange(Actor* actor) {
+    return sqrtf(gAttentionRanges[actor->attentionRangeType].attentionRangeSq /
+                 gAttentionRanges[actor->attentionRangeType].lockOnLeashScale);
 }
 
 /**
@@ -1950,7 +1953,7 @@ s32 Camera_Normal1(Camera* camera) {
     Vec3f spD8;
     f32 spD4;
     f32 spD0;
-    Vec3f* temp;
+    Vec3f* cameraDriftActorPos;
     f32 spC8;
     f32 spC4;
     f32 spC0;
@@ -2095,7 +2098,7 @@ s32 Camera_Normal1(Camera* camera) {
             camera->yawUpdateRateInv, phi_f2, 0.1f);
         if ((roData->interfaceFlags & NORMAL1_FLAG_3) && (camera->speedRatio > 0.01f)) {
             camera->pitchUpdateRateInv = Camera_ScaledStepToCeilF(100.0f, camera->pitchUpdateRateInv, 0.5f, 0.1f);
-        } else if (D_801ED920 != NULL) {
+        } else if (gCameraDriftActor != NULL) {
             camera->pitchUpdateRateInv = Camera_ScaledStepToCeilF(32.0f, camera->pitchUpdateRateInv, 0.5f, 0.1f);
         } else {
             camera->pitchUpdateRateInv = Camera_ScaledStepToCeilF(16.0f, camera->pitchUpdateRateInv, 0.2f, 0.1f);
@@ -2202,7 +2205,7 @@ s32 Camera_Normal1(Camera* camera) {
         spB4.yaw = sp9C.yaw;
         spB4.pitch = sp9C.pitch;
         camera->animState = 20;
-    } else if (D_801ED920 != NULL) {
+    } else if (gCameraDriftActor != NULL) {
         VecGeo sp74;
         s16 sp72;
         f32 sp6C;
@@ -2210,8 +2213,8 @@ s32 Camera_Normal1(Camera* camera) {
         //! FAKE:
         if (1) {}
 
-        temp = &D_801ED920->world.pos;
-        sp74 = OLib_Vec3fDiffToVecGeo(&focalActorPosRot->pos, temp);
+        cameraDriftActorPos = &gCameraDriftActor->world.pos;
+        sp74 = OLib_Vec3fDiffToVecGeo(&focalActorPosRot->pos, cameraDriftActorPos);
         sp72 = focalActorPosRot->rot.y - sp74.yaw;
         // Interface and shrink-window flags
         if ((roData->interfaceFlags & 0xFF00) == 0xFF00) {
@@ -3683,7 +3686,7 @@ s32 Camera_Battle1(Camera* camera) {
     sp120.y += focalActorHeight;
     spA4 = OLib_Vec3fDiffToVecGeo(&sp120, &camera->targetPosRot.pos);
 
-    sp104 = func_800CD6CC(camera->target);
+    sp104 = Camera_GetAttentionActorRange(camera->target);
     if (sp104 > (PREG(86) + 800.0f)) {
         sp104 = PREG(86) + 800.0f;
     }
diff --git a/src/code/z_en_item00.c b/src/code/z_en_item00.c
index ff79445973..0be9a94a1c 100644
--- a/src/code/z_en_item00.c
+++ b/src/code/z_en_item00.c
@@ -59,7 +59,7 @@ static ColliderCylinderInit sCylinderInit = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_STOP),
 };
 
 static s32 sBssPad;
diff --git a/src/overlays/actors/ovl_Boss_05/z_boss_05.c b/src/overlays/actors/ovl_Boss_05/z_boss_05.c
index 524842b5b7..2731cec97a 100644
--- a/src/overlays/actors/ovl_Boss_05/z_boss_05.c
+++ b/src/overlays/actors/ovl_Boss_05/z_boss_05.c
@@ -798,7 +798,7 @@ void Boss05_LilyPadWithHead_Move(Boss05* this, PlayState* play) {
 
                 if (player2->focusActor == &this->dyna.actor) {
                     player2->focusActor = &child->dyna.actor;
-                    play->actorCtx.attention.fairyActor = &child->dyna.actor;
+                    play->actorCtx.attention.tatlHoverActor = &child->dyna.actor;
                     play->actorCtx.attention.reticleActor = &child->dyna.actor;
                 }
 
@@ -929,7 +929,7 @@ void Boss05_FallingHead_Fall(Boss05* this, PlayState* play) {
 
                 if (player->focusActor == &this->dyna.actor) {
                     player->focusActor = &walkingHead->dyna.actor;
-                    play->actorCtx.attention.fairyActor = &walkingHead->dyna.actor;
+                    play->actorCtx.attention.tatlHoverActor = &walkingHead->dyna.actor;
                     play->actorCtx.attention.reticleActor = &walkingHead->dyna.actor;
                 }
 
diff --git a/src/overlays/actors/ovl_Dm_Char00/z_dm_char00.c b/src/overlays/actors/ovl_Dm_Char00/z_dm_char00.c
index 07e0985434..65db95a779 100644
--- a/src/overlays/actors/ovl_Dm_Char00/z_dm_char00.c
+++ b/src/overlays/actors/ovl_Dm_Char00/z_dm_char00.c
@@ -673,7 +673,7 @@ void DmChar00_Init(Actor* thisx, PlayState* play) {
     this->unk_240 = D_80AA77A8[DMCHAR00_GET(thisx)];
     this->unk_250 = D_80AA77D8[DMCHAR00_GET(thisx)];
 
-    thisx->targetArrowOffset = 3000.0f;
+    thisx->lockOnArrowOffset = 3000.0f;
     this->cueId = 99;
     this->unk_262 = DMCHAR00_GET_F800(thisx);
 
diff --git a/src/overlays/actors/ovl_Dm_Char02/z_dm_char02.c b/src/overlays/actors/ovl_Dm_Char02/z_dm_char02.c
index de54b6ce12..8029f63937 100644
--- a/src/overlays/actors/ovl_Dm_Char02/z_dm_char02.c
+++ b/src/overlays/actors/ovl_Dm_Char02/z_dm_char02.c
@@ -86,7 +86,7 @@ void DmChar02_Init(Actor* thisx, PlayState* play) {
 
     if (gSaveContext.save.saveInfo.inventory.items[SLOT_OCARINA] == ITEM_NONE) {
         this->animIndex = DMCHAR02_ANIM_HIT_GROUND;
-        this->actor.targetArrowOffset = 3000.0f;
+        this->actor.lockOnArrowOffset = 3000.0f;
         ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 24.0f);
         SkelAnime_InitFlex(play, &this->skelAnime, &gClockTowerOcarinaOfTimeSkel, NULL, NULL, NULL, 0);
         DmChar02_ChangeAnim(&this->skelAnime, &sAnimationInfo[DMCHAR02_ANIM_HIT_GROUND], 0);
diff --git a/src/overlays/actors/ovl_Dm_Char03/z_dm_char03.c b/src/overlays/actors/ovl_Dm_Char03/z_dm_char03.c
index 4b881e12f9..8fabe23ce2 100644
--- a/src/overlays/actors/ovl_Dm_Char03/z_dm_char03.c
+++ b/src/overlays/actors/ovl_Dm_Char03/z_dm_char03.c
@@ -59,7 +59,7 @@ void DmChar03_Init(Actor* thisx, PlayState* play) {
     DmChar03* this = THIS;
 
     this->animIndex = DMCHAR03_ANIM_FALL_OVER;
-    this->actor.targetArrowOffset = 3000.0f;
+    this->actor.lockOnArrowOffset = 3000.0f;
     this->unk_18E = false;
     ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 24.0f);
     SkelAnime_InitFlex(play, &this->skelAnime, &gDekuMaskSkel, NULL, NULL, NULL, 0);
diff --git a/src/overlays/actors/ovl_Dm_Char04/z_dm_char04.c b/src/overlays/actors/ovl_Dm_Char04/z_dm_char04.c
index a957b86069..747e5b84cc 100644
--- a/src/overlays/actors/ovl_Dm_Char04/z_dm_char04.c
+++ b/src/overlays/actors/ovl_Dm_Char04/z_dm_char04.c
@@ -72,7 +72,7 @@ void DmChar04_Init(Actor* thisx, PlayState* play) {
 
     this->primColors = sPrimColors[this->actor.params];
     this->envColors = sEnvColors[this->actor.params];
-    this->actor.targetArrowOffset = 3000.0f;
+    this->actor.lockOnArrowOffset = 3000.0f;
     this->cueId = 99;
     this->timer = this->actor.params << 0xB;
     ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 24.0f);
diff --git a/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.c b/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.c
index 445837702a..f20404af8b 100644
--- a/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.c
+++ b/src/overlays/actors/ovl_Dm_Char08/z_dm_char08.c
@@ -148,7 +148,7 @@ void DmChar08_Init(Actor* thisx, PlayState* play2) {
 
     thisx->attentionRangeType = ATTENTION_RANGE_5;
     this->eyeMode = TURTLE_EYEMODE_CLOSED;
-    thisx->targetArrowOffset = 120.0f;
+    thisx->lockOnArrowOffset = 120.0f;
     ActorShape_Init(&thisx->shape, 0.0f, ActorShadow_DrawCircle, 24.0f);
     SkelAnime_InitFlex(play, &this->skelAnime, &gTurtleSkel, NULL, NULL, NULL, 0);
     Actor_ProcessInitChain(thisx, sInitChain);
@@ -1018,7 +1018,7 @@ void DmChar08_Update(Actor* thisx, PlayState* play) {
     DmChar08* this = THIS;
 
     this->dyna.actor.focus.pos.x = this->focusPos.x;
-    this->dyna.actor.focus.pos.y = this->focusPos.y + this->dyna.actor.targetArrowOffset;
+    this->dyna.actor.focus.pos.y = this->focusPos.y + this->dyna.actor.lockOnArrowOffset;
     this->dyna.actor.focus.pos.z = this->focusPos.z;
     this->dyna.actor.focus.rot.x = this->dyna.actor.world.rot.x;
     this->dyna.actor.focus.rot.y = this->dyna.actor.world.rot.y;
diff --git a/src/overlays/actors/ovl_Dm_Sa/z_dm_sa.c b/src/overlays/actors/ovl_Dm_Sa/z_dm_sa.c
index 256ffbd1d3..39e6238aa0 100644
--- a/src/overlays/actors/ovl_Dm_Sa/z_dm_sa.c
+++ b/src/overlays/actors/ovl_Dm_Sa/z_dm_sa.c
@@ -60,7 +60,7 @@ void DmSa_Init(Actor* thisx, PlayState* play) {
 
     this->unk_2E0 = 0;
     this->alpha = 255;
-    this->actor.targetArrowOffset = 3000.0f;
+    this->actor.lockOnArrowOffset = 3000.0f;
     ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 24.0f);
     SkelAnime_InitFlex(play, &this->skelAnime, &gSkullKidSkel, NULL, NULL, NULL, 0);
     DmSa_ChangeAnim(&this->skelAnime, &sAnimationInfo[DMSA_ANIM_T_POSE], 0);
diff --git a/src/overlays/actors/ovl_Dm_Stk/z_dm_stk.c b/src/overlays/actors/ovl_Dm_Stk/z_dm_stk.c
index 8c15efb714..97f34e6c45 100644
--- a/src/overlays/actors/ovl_Dm_Stk/z_dm_stk.c
+++ b/src/overlays/actors/ovl_Dm_Stk/z_dm_stk.c
@@ -1167,7 +1167,7 @@ void DmStk_Init(Actor* thisx, PlayState* play) {
         this->fadeOutState = SK_FADE_OUT_STATE_NONE;
         this->fadeOutTimer = 0;
         this->alpha = this->alpha; // Set to itself
-        this->actor.targetArrowOffset = 1100.0f;
+        this->actor.lockOnArrowOffset = 1100.0f;
         this->cueId = 99;
         ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 24.0f);
         SkelAnime_InitFlex(play, &this->skelAnime, &gSkullKidSkel, NULL, NULL, NULL, 0);
@@ -1796,9 +1796,9 @@ void DmStk_ClockTower_Idle(DmStk* this, PlayState* play) {
         this->actor.flags |= ACTOR_FLAG_ATTENTION_ENABLED;
 
         if (this->animIndex == SK_ANIM_CALL_DOWN_MOON_LOOP) {
-            this->actor.targetArrowOffset = 3100.0f;
+            this->actor.lockOnArrowOffset = 3100.0f;
         } else {
-            this->actor.targetArrowOffset = 200.0f;
+            this->actor.lockOnArrowOffset = 200.0f;
         }
 
         if ((this->collider.base.acFlags & AC_HIT) && (this->actor.colChkInfo.damageEffect == 0xF)) {
diff --git a/src/overlays/actors/ovl_Dm_Zl/z_dm_zl.c b/src/overlays/actors/ovl_Dm_Zl/z_dm_zl.c
index fc27485f9b..9cad5d869d 100644
--- a/src/overlays/actors/ovl_Dm_Zl/z_dm_zl.c
+++ b/src/overlays/actors/ovl_Dm_Zl/z_dm_zl.c
@@ -116,7 +116,7 @@ void DmZl_Init(Actor* thisx, PlayState* play) {
 
     this->animIndex = ZELDA_ANIM_FACING_AWAY;
     this->unk_2BA = 0;
-    this->actor.targetArrowOffset = 1000.0f;
+    this->actor.lockOnArrowOffset = 1000.0f;
     ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 24.0f);
     // these three set to NULL should mean they are dynamically allocated
     SkelAnime_InitFlex(play, &this->skelAnime, &gZl4Skel, NULL, NULL, NULL, 0);
diff --git a/src/overlays/actors/ovl_En_Akindonuts/z_en_akindonuts.c b/src/overlays/actors/ovl_En_Akindonuts/z_en_akindonuts.c
index 4537f2d7b4..c478e0d234 100644
--- a/src/overlays/actors/ovl_En_Akindonuts/z_en_akindonuts.c
+++ b/src/overlays/actors/ovl_En_Akindonuts/z_en_akindonuts.c
@@ -153,7 +153,7 @@ static u16 D_80BF04AC[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_0, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 30, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 30, ICHAIN_STOP),
 };
 
 void func_80BECBE0(EnAkindonuts* this, s16 arg1) {
diff --git a/src/overlays/actors/ovl_En_Am/z_en_am.c b/src/overlays/actors/ovl_En_Am/z_en_am.c
index 021dff4d5e..ba09b01ac8 100644
--- a/src/overlays/actors/ovl_En_Am/z_en_am.c
+++ b/src/overlays/actors/ovl_En_Am/z_en_am.c
@@ -129,7 +129,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_VEC3F_DIV1000(scale, 14, ICHAIN_CONTINUE),
     ICHAIN_S8(hintId, TATL_HINT_ID_ARMOS, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -4000, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_STOP),
 };
 
 void EnAm_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Attack_Niw/z_en_attack_niw.c b/src/overlays/actors/ovl_En_Attack_Niw/z_en_attack_niw.c
index 70f665acf2..4e216da28c 100644
--- a/src/overlays/actors/ovl_En_Attack_Niw/z_en_attack_niw.c
+++ b/src/overlays/actors/ovl_En_Attack_Niw/z_en_attack_niw.c
@@ -35,7 +35,7 @@ ActorProfile En_Attack_Niw_Profile = {
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_1, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 0, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 0, ICHAIN_STOP),
 };
 
 void EnAttackNiw_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Bat/z_en_bat.c b/src/overlays/actors/ovl_En_Bat/z_en_bat.c
index c3a031fa9f..ec1fa4ba18 100644
--- a/src/overlays/actors/ovl_En_Bat/z_en_bat.c
+++ b/src/overlays/actors/ovl_En_Bat/z_en_bat.c
@@ -111,7 +111,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_BAD_BAT, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneForward, 3000, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -500, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_STOP),
 };
 
 static Gfx* sWingsDLs[] = {
diff --git a/src/overlays/actors/ovl_En_Bb/z_en_bb.c b/src/overlays/actors/ovl_En_Bb/z_en_bb.c
index c69c8c331c..1c330e3058 100644
--- a/src/overlays/actors/ovl_En_Bb/z_en_bb.c
+++ b/src/overlays/actors/ovl_En_Bb/z_en_bb.c
@@ -116,7 +116,7 @@ static CollisionCheckInfoInit sColChkInfoInit = { 2, 20, 40, 50 };
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_BLUE_BUBBLE, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 10, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 10, ICHAIN_STOP),
 };
 
 void EnBb_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c b/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c
index f21d318a82..d4f57151ee 100644
--- a/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c
+++ b/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c
@@ -145,7 +145,7 @@ static CollisionCheckInfoInit sColChkInfoInit = { 2, 20, 40, 50 };
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_RED_BUBBLE, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 10, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 10, ICHAIN_STOP),
 };
 
 void EnBbfall_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Bigokuta/z_en_bigokuta.c b/src/overlays/actors/ovl_En_Bigokuta/z_en_bigokuta.c
index 3a79793314..2d6a951453 100644
--- a/src/overlays/actors/ovl_En_Bigokuta/z_en_bigokuta.c
+++ b/src/overlays/actors/ovl_En_Bigokuta/z_en_bigokuta.c
@@ -87,7 +87,7 @@ static CollisionCheckInfoInit sColChkInfoInit = { 4, 130, 120, MASS_HEAVY };
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 2500, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_2, ICHAIN_CONTINUE),
     ICHAIN_S8(hintId, TATL_HINT_ID_BIG_OCTO, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 33, ICHAIN_STOP),
diff --git a/src/overlays/actors/ovl_En_Bigpamet/z_en_bigpamet.c b/src/overlays/actors/ovl_En_Bigpamet/z_en_bigpamet.c
index c343fe02d3..0aad494f22 100644
--- a/src/overlays/actors/ovl_En_Bigpamet/z_en_bigpamet.c
+++ b/src/overlays/actors/ovl_En_Bigpamet/z_en_bigpamet.c
@@ -126,7 +126,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, 1, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 15, ICHAIN_CONTINUE),
     ICHAIN_F32(gravity, -2, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 4333, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 4333, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_5, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Bigpo/z_en_bigpo.c b/src/overlays/actors/ovl_En_Bigpo/z_en_bigpo.c
index 37b09a0437..a13f198bb6 100644
--- a/src/overlays/actors/ovl_En_Bigpo/z_en_bigpo.c
+++ b/src/overlays/actors/ovl_En_Bigpo/z_en_bigpo.c
@@ -155,7 +155,7 @@ static DamageTable sDamageTable = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_BIG_POE, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 3200, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 3200, ICHAIN_STOP),
 };
 
 // used in the burning death actionfunc
diff --git a/src/overlays/actors/ovl_En_Bigslime/z_en_bigslime.c b/src/overlays/actors/ovl_En_Bigslime/z_en_bigslime.c
index 42294291ac..61081cd6d2 100644
--- a/src/overlays/actors/ovl_En_Bigslime/z_en_bigslime.c
+++ b/src/overlays/actors/ovl_En_Bigslime/z_en_bigslime.c
@@ -306,7 +306,7 @@ static AnimationHeader* sGekkoAttackAnimations[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_GEKKO_GIANT_SLIME, ICHAIN_CONTINUE),
-    ICHAIN_F32_DIV1000(targetArrowOffset, -13221, ICHAIN_CONTINUE),
+    ICHAIN_F32_DIV1000(lockOnArrowOffset, -13221, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_5, ICHAIN_STOP),
 };
diff --git a/src/overlays/actors/ovl_En_Bom/z_en_bom.c b/src/overlays/actors/ovl_En_Bom/z_en_bom.c
index 8383e77cdd..224fd3a425 100644
--- a/src/overlays/actors/ovl_En_Bom/z_en_bom.c
+++ b/src/overlays/actors/ovl_En_Bom/z_en_bom.c
@@ -124,7 +124,7 @@ static ColliderJntSphInit sJntSphInit2 = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_VEC3F(scale, 0, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -4000, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Crow/z_en_crow.c b/src/overlays/actors/ovl_En_Crow/z_en_crow.c
index 4d29207b14..d3201cc2bf 100644
--- a/src/overlays/actors/ovl_En_Crow/z_en_crow.c
+++ b/src/overlays/actors/ovl_En_Crow/z_en_crow.c
@@ -121,7 +121,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 3000, ICHAIN_CONTINUE),
     ICHAIN_S8(hintId, TATL_HINT_ID_GUAY, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -500, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_STOP),
 };
 
 void EnCrow_Init(Actor* thisx, PlayState* play) {
@@ -301,7 +301,7 @@ void EnCrow_SetupDamaged(EnCrow* this, PlayState* play) {
     this->actor.velocity.y = 0.0f;
     Animation_Change(&this->skelAnime, &gGuayFlyAnim, 0.4f, 0.0f, 0.0f, ANIMMODE_LOOP_INTERP, -3.0f);
     this->actor.shape.yOffset = 0.0f;
-    this->actor.targetArrowOffset = 0.0f;
+    this->actor.lockOnArrowOffset = 0.0f;
     this->actor.bgCheckFlags &= ~BGCHECKFLAG_GROUND;
     scale = (this->actor.scale.x * 100.0f);
     this->actor.world.pos.y += 20.0f * scale;
@@ -438,7 +438,7 @@ void EnCrow_SetupRespawn(EnCrow* this) {
     this->timer = 300;
     this->actor.draw = NULL;
     this->actor.shape.yOffset = 2000.0f;
-    this->actor.targetArrowOffset = 2000.0;
+    this->actor.lockOnArrowOffset = 2000.0;
     this->drawDmgEffAlpha = 0.0f;
     this->actionFunc = EnCrow_Respawn;
 }
diff --git a/src/overlays/actors/ovl_En_Death/z_en_death.c b/src/overlays/actors/ovl_En_Death/z_en_death.c
index f2a2c8493f..95a53ae4c7 100644
--- a/src/overlays/actors/ovl_En_Death/z_en_death.c
+++ b/src/overlays/actors/ovl_En_Death/z_en_death.c
@@ -221,7 +221,7 @@ static EffectBlureInit2 sBlureInit = {
 static InitChainEntry sInitChain[] = {
     ICHAIN_VEC3F(scale, 0, ICHAIN_CONTINUE),
     ICHAIN_S8(hintId, TATL_HINT_ID_GOMESS, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 6000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 6000, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_5, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Dekubaba/z_en_dekubaba.c b/src/overlays/actors/ovl_En_Dekubaba/z_en_dekubaba.c
index 1487018524..a147f1ccd8 100644
--- a/src/overlays/actors/ovl_En_Dekubaba/z_en_dekubaba.c
+++ b/src/overlays/actors/ovl_En_Dekubaba/z_en_dekubaba.c
@@ -197,7 +197,7 @@ static DamageTable sDamageTable = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 1500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1500, ICHAIN_STOP),
 };
 
 void EnDekubaba_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c b/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
index c3a9b30e26..b6ff58443f 100644
--- a/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
+++ b/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
@@ -112,7 +112,7 @@ static DamageTable sDamageTable = {
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_MAD_SCRUB, ICHAIN_CONTINUE),
     ICHAIN_F32(gravity, -1, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2600, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2600, ICHAIN_STOP),
 };
 
 void EnDekunuts_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c b/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c
index ba2288d90f..009a04cbf1 100644
--- a/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c
+++ b/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c
@@ -262,7 +262,7 @@ static s16 sCsId = CS_ID_NONE;
 static s32 sNumAlive = 0;
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_S8(hintId, TATL_HINT_ID_DINOLFOS, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 15, ICHAIN_STOP),
diff --git a/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c b/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
index 9d28b98292..6e0cc31328 100644
--- a/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
+++ b/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
@@ -276,7 +276,7 @@ static CollisionCheckInfoInit sColChkInfoInit = { 3, 100, 100, 80 };
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_DODONGO, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -1000, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1400, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1400, ICHAIN_STOP),
 };
 
 void EnDodongo_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Elf/z_en_elf.c b/src/overlays/actors/ovl_En_Elf/z_en_elf.c
index e3a12e904d..52da2288da 100644
--- a/src/overlays/actors/ovl_En_Elf/z_en_elf.c
+++ b/src/overlays/actors/ovl_En_Elf/z_en_elf.c
@@ -886,7 +886,7 @@ void func_8088E60C(EnElf* this, PlayState* play) {
 void func_8088E850(EnElf* this, PlayState* play) {
     Vec3f nextPos;
     Player* player = GET_PLAYER(play);
-    Actor* targetFairyActor;
+    Actor* tatlHoverActor;
     f32 xScale;
     f32 distFromLinksHead;
     u32 cueChannel;
@@ -972,15 +972,15 @@ void func_8088E850(EnElf* this, PlayState* play) {
                 break;
 
             default:
-                targetFairyActor = play->actorCtx.attention.fairyActor;
+                tatlHoverActor = play->actorCtx.attention.tatlHoverActor;
                 if ((player->stateFlags1 & PLAYER_STATE1_40) && (player->talkActor != NULL)) {
                     Math_Vec3f_Copy(&nextPos, &player->talkActor->focus.pos);
                 } else {
-                    Math_Vec3f_Copy(&nextPos, &play->actorCtx.attention.fairyPos);
+                    Math_Vec3f_Copy(&nextPos, &play->actorCtx.attention.tatlHoverPos);
                 }
                 nextPos.y += 1500.0f * this->actor.scale.y;
 
-                if (targetFairyActor != NULL) {
+                if (tatlHoverActor != NULL) {
                     func_8088DB4C(this, &nextPos, 0.0f, 30.0f, 0.2f);
                     if (this->actor.speed >= 5.0f) {
                         func_8088F5F4(this, play, 0x10);
@@ -1041,7 +1041,7 @@ void func_8088EF18(Color_RGBAf* dest, Color_RGBAf* newColor, Color_RGBAf* curCol
 }
 
 void func_8088EFA4(EnElf* this, PlayState* play) {
-    Actor* targetFairyActor = play->actorCtx.attention.fairyActor;
+    Actor* tatlHoverActor = play->actorCtx.attention.tatlHoverActor;
     Player* player = GET_PLAYER(play);
     f32 transitionRate;
 
@@ -1066,35 +1066,35 @@ void func_8088EFA4(EnElf* this, PlayState* play) {
             this->outerColor.b = 80.0f;
             this->outerColor.a = 0.0f;
         }
-    } else if (play->actorCtx.attention.fairyMoveProgressFactor != 0.0f) {
+    } else if (play->actorCtx.attention.tatlMoveProgressFactor != 0.0f) {
         this->unk_268 = 0;
         this->unk_238 = 1.0f;
         if (!this->unk_269) {
             Actor_PlaySfx(&this->actor, NA_SE_EV_BELL_DASH_NORMAL);
         }
     } else if (this->unk_268 == 0) {
-        if ((targetFairyActor == NULL) ||
-            (Math_Vec3f_DistXYZ(&this->actor.world.pos, &play->actorCtx.attention.fairyPos) < 50.0f)) {
+        if ((tatlHoverActor == NULL) ||
+            (Math_Vec3f_DistXYZ(&this->actor.world.pos, &play->actorCtx.attention.tatlHoverPos) < 50.0f)) {
             this->unk_268 = 1;
         }
     } else if (this->unk_238 != 0.0f) {
         if (Math_StepToF(&this->unk_238, 0.0f, 0.25f)) {
-            this->innerColor = play->actorCtx.attention.fairyInnerColor;
-            this->outerColor = play->actorCtx.attention.fairyOuterColor;
+            this->innerColor = play->actorCtx.attention.tatlInnerColor;
+            this->outerColor = play->actorCtx.attention.tatlOuterColor;
         } else {
             transitionRate = 0.25f / this->unk_238;
-            func_8088EF18(&this->innerColor, &play->actorCtx.attention.fairyInnerColor, &this->innerColor,
+            func_8088EF18(&this->innerColor, &play->actorCtx.attention.tatlInnerColor, &this->innerColor,
                           transitionRate);
-            func_8088EF18(&this->outerColor, &play->actorCtx.attention.fairyOuterColor, &this->outerColor,
+            func_8088EF18(&this->outerColor, &play->actorCtx.attention.tatlOuterColor, &this->outerColor,
                           transitionRate);
         }
     }
 
     if (this->fairyFlags & 1) {
-        if ((targetFairyActor == NULL) || (player->focusActor == NULL)) {
+        if ((tatlHoverActor == NULL) || (player->focusActor == NULL)) {
             this->fairyFlags ^= 1;
         }
-    } else if ((targetFairyActor != NULL) && (player->focusActor != NULL)) {
+    } else if ((tatlHoverActor != NULL) && (player->focusActor != NULL)) {
         u8 temp = this->unk_269;
         u16 targetSfxId = (this->unk_269 == 0) ? NA_SE_NONE : NA_SE_NONE;
 
@@ -1107,7 +1107,7 @@ void func_8088EFA4(EnElf* this, PlayState* play) {
 
 void func_8088F214(EnElf* this, PlayState* play) {
     s32 sp34;
-    Actor* targetFairyActor;
+    Actor* tatlHoverActor;
     Player* player = GET_PLAYER(play);
     s32 pad;
 
@@ -1138,12 +1138,12 @@ void func_8088F214(EnElf* this, PlayState* play) {
         sp34 = 1;
         Actor_PlaySfx_Flagged(&this->actor, NA_SE_EV_BELL_ANGER - SFX_FLAG);
     } else {
-        targetFairyActor = play->actorCtx.attention.fairyActor;
+        tatlHoverActor = play->actorCtx.attention.tatlHoverActor;
         if (player->stateFlags1 & PLAYER_STATE1_400) {
             sp34 = 10;
             this->unk_25C = 100;
-        } else if ((targetFairyActor == NULL) || (targetFairyActor->category == ACTORCAT_NPC)) {
-            if (targetFairyActor != NULL) {
+        } else if ((tatlHoverActor == NULL) || (tatlHoverActor->category == ACTORCAT_NPC)) {
+            if (tatlHoverActor != NULL) {
                 this->unk_25C = 100;
                 player->stateFlags2 |= PLAYER_STATE2_100000;
                 sp34 = 0;
@@ -1282,7 +1282,7 @@ void func_8088FA38(EnElf* this, PlayState* play) {
     Player* player = GET_PLAYER(play);
 
     if (this->fairyFlags & 0x10) {
-        refPos = play->actorCtx.attention.fairyPos;
+        refPos = play->actorCtx.attention.tatlHoverPos;
 
         if (this->unk_234 != NULL) {
             refPos = this->unk_234->world.pos;
diff --git a/src/overlays/actors/ovl_En_Famos/z_en_famos.c b/src/overlays/actors/ovl_En_Famos/z_en_famos.c
index b31d2a4c60..5907b69c75 100644
--- a/src/overlays/actors/ovl_En_Famos/z_en_famos.c
+++ b/src/overlays/actors/ovl_En_Famos/z_en_famos.c
@@ -151,7 +151,7 @@ static AnimatedMaterial* sEmblemAnimatedMats[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_DEATH_ARMOS, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 3500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 3500, ICHAIN_STOP),
 };
 
 static s32 sAnimatedMaterialsDesgmented = false;
diff --git a/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c b/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
index 67ac493b5b..0e0246d59d 100644
--- a/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
+++ b/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
@@ -126,7 +126,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_VEC3F_DIV1000(scale, 5, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -500, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_2, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 4000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 4000, ICHAIN_STOP),
 };
 
 void EnFirefly_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Fishing/z_en_fishing.c b/src/overlays/actors/ovl_En_Fishing/z_en_fishing.c
index 01741eb7ea..e51b7ba20e 100644
--- a/src/overlays/actors/ovl_En_Fishing/z_en_fishing.c
+++ b/src/overlays/actors/ovl_En_Fishing/z_en_fishing.c
@@ -793,7 +793,7 @@ FishingFishInit sFishInits[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_5, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 0, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 0, ICHAIN_STOP),
 };
 
 void EnFishing_Init(Actor* thisx, PlayState* play2) {
diff --git a/src/overlays/actors/ovl_En_Floormas/z_en_floormas.c b/src/overlays/actors/ovl_En_Floormas/z_en_floormas.c
index ee9cb440e7..357af6cc38 100644
--- a/src/overlays/actors/ovl_En_Floormas/z_en_floormas.c
+++ b/src/overlays/actors/ovl_En_Floormas/z_en_floormas.c
@@ -131,7 +131,7 @@ static DamageTable sDamageTable = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_FLOORMASTER, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 5500, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 5500, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -1000, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Fr/z_en_fr.c b/src/overlays/actors/ovl_En_Fr/z_en_fr.c
index 3e8905813a..d0d240e229 100644
--- a/src/overlays/actors/ovl_En_Fr/z_en_fr.c
+++ b/src/overlays/actors/ovl_En_Fr/z_en_fr.c
@@ -1,12 +1,13 @@
 /*
  * File: z_en_fr.c
  * Overlay: ovl_En_Fr
- * Description:
+ * Description: Invisible spot that triggers a slow camera drift towards the spot while player is moving.
+ *              Unused in game.
  */
 
 #include "z_en_fr.h"
 
-#define FLAGS (ACTOR_FLAG_40000000)
+#define FLAGS (ACTOR_FLAG_CAMERA_DRIFT_ENABLED)
 
 #define THIS ((EnFr*)thisx)
 
@@ -34,7 +35,7 @@ void EnFr_Init(Actor* thisx, PlayState* play) {
         return;
     }
 
-    this->actor.attentionRangeType = ENFR_GET_TARGETMODE(&this->actor);
+    this->actor.attentionRangeType = ENFR_GET_ATTENTION_RANGE_TYPE(&this->actor);
 }
 
 void EnFr_Destroy(Actor* thisx, PlayState* play) {
@@ -49,8 +50,8 @@ void EnFr_Update(Actor* thisx, PlayState* play) {
     }
 
     if (this->actor.xyzDistToPlayerSq < SQ(IREG(29))) {
-        this->actor.flags &= ~ACTOR_FLAG_40000000;
+        this->actor.flags &= ~ACTOR_FLAG_CAMERA_DRIFT_ENABLED;
     } else {
-        this->actor.flags |= ACTOR_FLAG_40000000;
+        this->actor.flags |= ACTOR_FLAG_CAMERA_DRIFT_ENABLED;
     }
 }
diff --git a/src/overlays/actors/ovl_En_Fr/z_en_fr.h b/src/overlays/actors/ovl_En_Fr/z_en_fr.h
index 0227608fb6..475840a781 100644
--- a/src/overlays/actors/ovl_En_Fr/z_en_fr.h
+++ b/src/overlays/actors/ovl_En_Fr/z_en_fr.h
@@ -6,7 +6,7 @@
 struct EnFr;
 
 #define ENFR_GET_SWITCH_FLAG(thisx) ((thisx)->params & 0x7F)
-#define ENFR_GET_TARGETMODE(thisx) (((thisx)->params >> 7) & 0xF)
+#define ENFR_GET_ATTENTION_RANGE_TYPE(thisx) (((thisx)->params >> 7) & 0xF)
 
 typedef struct EnFr {
     /* 0x000 */ Actor actor;
diff --git a/src/overlays/actors/ovl_En_Fz/z_en_fz.c b/src/overlays/actors/ovl_En_Fz/z_en_fz.c
index 90e769eba2..8f5d81b928 100644
--- a/src/overlays/actors/ovl_En_Fz/z_en_fz.c
+++ b/src/overlays/actors/ovl_En_Fz/z_en_fz.c
@@ -160,7 +160,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_FREEZARD, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_2, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneForward, 1400, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 30, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 30, ICHAIN_STOP),
 };
 
 void EnFz_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Gb2/z_en_gb2.c b/src/overlays/actors/ovl_En_Gb2/z_en_gb2.c
index ca0a7de06c..05be5edd90 100644
--- a/src/overlays/actors/ovl_En_Gb2/z_en_gb2.c
+++ b/src/overlays/actors/ovl_En_Gb2/z_en_gb2.c
@@ -880,7 +880,7 @@ void func_80B11344(EnGb2* this, PlayState* play) {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_4, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2200, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2200, ICHAIN_STOP),
 };
 
 void EnGb2_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Hint_Skb/z_en_hint_skb.c b/src/overlays/actors/ovl_En_Hint_Skb/z_en_hint_skb.c
index 4ee8b52dbd..4fae1d7c0b 100644
--- a/src/overlays/actors/ovl_En_Hint_Skb/z_en_hint_skb.c
+++ b/src/overlays/actors/ovl_En_Hint_Skb/z_en_hint_skb.c
@@ -161,7 +161,7 @@ static AnimationInfo sAnimationInfo[STALCHILD_HINT_ANIM_MAX] = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Ik/z_en_ik.c b/src/overlays/actors/ovl_En_Ik/z_en_ik.c
index 97ce3e580e..7e7cb43339 100644
--- a/src/overlays/actors/ovl_En_Ik/z_en_ik.c
+++ b/src/overlays/actors/ovl_En_Ik/z_en_ik.c
@@ -246,7 +246,7 @@ static DamageTable sDamageTableNoArmor = {
 static CollisionCheckInfoInit sColChkInfoInit = { 18, 25, 80, MASS_HEAVY };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2916, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2916, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 12, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -1000, ICHAIN_STOP),
 };
diff --git a/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c b/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c
index 7a7d33950a..b38d6bbf1f 100644
--- a/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c
+++ b/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c
@@ -2057,7 +2057,7 @@ void EnInvadepoh_CowTail_Init(EnInvadepoh* this, PlayState* play) {
 
 static InitChainEntry sRomaniInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 20000, ICHAIN_CONTINUE), ICHAIN_F32(uncullZoneScale, 100, ICHAIN_CONTINUE),
-    ICHAIN_F32(uncullZoneDownward, 100, ICHAIN_CONTINUE),  ICHAIN_F32(targetArrowOffset, 1500, ICHAIN_CONTINUE),
+    ICHAIN_F32(uncullZoneDownward, 100, ICHAIN_CONTINUE),  ICHAIN_F32(lockOnArrowOffset, 1500, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 10, ICHAIN_STOP),
 };
 
@@ -2179,7 +2179,7 @@ static InitChainEntry sCremiaInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 20000, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneScale, 100, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneDownward, 150, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1500, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 1500, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_3, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 10, ICHAIN_STOP),
 };
diff --git a/src/overlays/actors/ovl_En_Invadepoh_Demo/z_en_invadepoh_demo.c b/src/overlays/actors/ovl_En_Invadepoh_Demo/z_en_invadepoh_demo.c
index 1079052dd5..eaf1c36851 100644
--- a/src/overlays/actors/ovl_En_Invadepoh_Demo/z_en_invadepoh_demo.c
+++ b/src/overlays/actors/ovl_En_Invadepoh_Demo/z_en_invadepoh_demo.c
@@ -116,7 +116,7 @@ static s32 sCueTypes[EN_INVADEPOH_DEMO_TYPE_MAX] = {
 
 static InitChainEntry sAlienInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 20000, ICHAIN_CONTINUE), ICHAIN_F32(uncullZoneScale, 500, ICHAIN_CONTINUE),
-    ICHAIN_F32(uncullZoneDownward, 600, ICHAIN_CONTINUE),  ICHAIN_F32(targetArrowOffset, 6000, ICHAIN_CONTINUE),
+    ICHAIN_F32(uncullZoneDownward, 600, ICHAIN_CONTINUE),  ICHAIN_F32(lockOnArrowOffset, 6000, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 10, ICHAIN_STOP),
 };
 
@@ -124,7 +124,7 @@ static InitChainEntry sRomaniInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 20000, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneScale, 100, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneDownward, 100, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1500, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 1500, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_6, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 10, ICHAIN_STOP),
 };
diff --git a/src/overlays/actors/ovl_En_Kakasi/z_en_kakasi.c b/src/overlays/actors/ovl_En_Kakasi/z_en_kakasi.c
index 7a3f49b466..9f129fc133 100644
--- a/src/overlays/actors/ovl_En_Kakasi/z_en_kakasi.c
+++ b/src/overlays/actors/ovl_En_Kakasi/z_en_kakasi.c
@@ -175,7 +175,7 @@ void EnKakasi_Init(Actor* thisx, PlayState* play) {
     this->picto.actor.world.rot.z = 0;
     this->picto.actor.attentionRangeType = ATTENTION_RANGE_0;
     if ((this->picto.actor.world.rot.x > 0) && (this->picto.actor.world.rot.x < 8)) {
-        this->picto.actor.attentionRangeType = KAKASI_GET_TARGETMODE(thisx);
+        this->picto.actor.attentionRangeType = KAKASI_GET_ATTENTION_RANGE_TYPE(thisx);
     }
     this->picto.actor.shape.rot.y = this->picto.actor.world.rot.y;
 
diff --git a/src/overlays/actors/ovl_En_Kakasi/z_en_kakasi.h b/src/overlays/actors/ovl_En_Kakasi/z_en_kakasi.h
index 689e475b2d..a7d0be2909 100644
--- a/src/overlays/actors/ovl_En_Kakasi/z_en_kakasi.h
+++ b/src/overlays/actors/ovl_En_Kakasi/z_en_kakasi.h
@@ -44,6 +44,6 @@ typedef struct EnKakasi {
 
 #define KAKASI_GET_SUMMON_DISTANCE(thisx) (((thisx)->params >> 0x8) & 0xFF) 
 #define KAKASI_GET_ABOVE_GROUND(thisx) ((thisx)->params & 0x1) 
-#define KAKASI_GET_TARGETMODE(thisx) ((thisx)->world.rot.x - 1)
+#define KAKASI_GET_ATTENTION_RANGE_TYPE(thisx) ((thisx)->world.rot.x - 1)
 
 #endif // Z_EN_KAKASI_H
diff --git a/src/overlays/actors/ovl_En_Kame/z_en_kame.c b/src/overlays/actors/ovl_En_Kame/z_en_kame.c
index f5cc49182c..94128aa4fd 100644
--- a/src/overlays/actors/ovl_En_Kame/z_en_kame.c
+++ b/src/overlays/actors/ovl_En_Kame/z_en_kame.c
@@ -143,7 +143,7 @@ static TexturePtr sEyeTextures[] = { gSnapperEyeOpenTex, gSnapperEyeHalfTex, gSn
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_SNAPPER, ICHAIN_CONTINUE),
     ICHAIN_F32(gravity, -1, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 3500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 3500, ICHAIN_STOP),
 };
 
 static s32 sTexturesDesegmented = false;
diff --git a/src/overlays/actors/ovl_En_Karebaba/z_en_karebaba.c b/src/overlays/actors/ovl_En_Karebaba/z_en_karebaba.c
index 76c7ecf111..3c2b62dcf0 100644
--- a/src/overlays/actors/ovl_En_Karebaba/z_en_karebaba.c
+++ b/src/overlays/actors/ovl_En_Karebaba/z_en_karebaba.c
@@ -137,7 +137,7 @@ static DamageTable sDamageTable = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2500, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2500, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_1, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Knight/z_en_knight.c b/src/overlays/actors/ovl_En_Knight/z_en_knight.c
index d82a2d6c11..b9dc9564a5 100644
--- a/src/overlays/actors/ovl_En_Knight/z_en_knight.c
+++ b/src/overlays/actors/ovl_En_Knight/z_en_knight.c
@@ -2180,7 +2180,7 @@ void EnKnight_FlyingHeadDone(EnKnight* this, PlayState* play) {
                 sIgosHeadInstance = NULL;
                 this->actor.flags |= ACTOR_FLAG_ATTENTION_ENABLED;
                 player->focusActor = &this->actor;
-                play->actorCtx.attention.fairyActor = &this->actor;
+                play->actorCtx.attention.tatlHoverActor = &this->actor;
                 play->actorCtx.attention.reticleActor = &this->actor;
             }
 
@@ -3259,7 +3259,7 @@ void EnKnight_FlyingHead(EnKnight* this, PlayState* play) {
             this->timers[0] = 20;
             sIgosInstance->actor.flags &= ~ACTOR_FLAG_ATTENTION_ENABLED;
             player->focusActor = &this->actor;
-            play->actorCtx.attention.fairyActor = &this->actor;
+            play->actorCtx.attention.tatlHoverActor = &this->actor;
             play->actorCtx.attention.reticleActor = &this->actor;
             Math_Vec3f_Copy(&this->actor.world.pos, &sIgosInstance->actor.world.pos);
             Math_Vec3s_Copy(&this->actor.world.rot, &sIgosInstance->actor.world.rot);
diff --git a/src/overlays/actors/ovl_En_Mkk/z_en_mkk.c b/src/overlays/actors/ovl_En_Mkk/z_en_mkk.c
index ac4b924d46..cbc9545cdb 100644
--- a/src/overlays/actors/ovl_En_Mkk/z_en_mkk.c
+++ b/src/overlays/actors/ovl_En_Mkk/z_en_mkk.c
@@ -107,7 +107,7 @@ static DamageTable sDamageTable = {
 static InitChainEntry sInitChain[] = {
     ICHAIN_F32_DIV1000(gravity, -500, ICHAIN_CONTINUE),
     ICHAIN_F32(terminalVelocity, -5, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 3000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 3000, ICHAIN_STOP),
 };
 
 static Color_RGBA8 D_80A4F780 = { 250, 250, 250, 255 };
diff --git a/src/overlays/actors/ovl_En_Ms/z_en_ms.c b/src/overlays/actors/ovl_En_Ms/z_en_ms.c
index aa619b6711..75c8668401 100644
--- a/src/overlays/actors/ovl_En_Ms/z_en_ms.c
+++ b/src/overlays/actors/ovl_En_Ms/z_en_ms.c
@@ -53,7 +53,7 @@ static ColliderCylinderInitType1 sCylinderInit = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_2, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 500, ICHAIN_STOP),
 };
 
 void EnMs_Init(Actor* thisx, PlayState* play) {
@@ -171,7 +171,7 @@ void EnMs_Update(Actor* thisx, PlayState* play) {
     EnMs* this = THIS;
 
     Actor_SetFocus(&this->actor, 20.0f);
-    this->actor.targetArrowOffset = 500.0f;
+    this->actor.lockOnArrowOffset = 500.0f;
     Actor_SetScale(&this->actor, 0.015f);
     SkelAnime_Update(&this->skelAnime);
     this->actionFunc(this, play);
diff --git a/src/overlays/actors/ovl_En_Niw/z_en_niw.c b/src/overlays/actors/ovl_En_Niw/z_en_niw.c
index 41f0663ec7..f9977b51e5 100644
--- a/src/overlays/actors/ovl_En_Niw/z_en_niw.c
+++ b/src/overlays/actors/ovl_En_Niw/z_en_niw.c
@@ -86,7 +86,7 @@ void EnNiw_Init(Actor* thisx, PlayState* play) {
     static InitChainEntry sInitChain[] = {
         ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_6, ICHAIN_CONTINUE),
         ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_CONTINUE),
-        ICHAIN_F32(targetArrowOffset, 0, ICHAIN_STOP),
+        ICHAIN_F32(lockOnArrowOffset, 0, ICHAIN_STOP),
     };
     EnNiw* this = THIS;
     Vec3f D_808934C4 = { 90000.0f, 90000.0f, 90000.0f };
diff --git a/src/overlays/actors/ovl_En_Okuta/z_en_okuta.c b/src/overlays/actors/ovl_En_Okuta/z_en_okuta.c
index 1ad2f50761..a690881bff 100644
--- a/src/overlays/actors/ovl_En_Okuta/z_en_okuta.c
+++ b/src/overlays/actors/ovl_En_Okuta/z_en_okuta.c
@@ -140,7 +140,7 @@ static DamageTable sDamageTable = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_OCTOROK, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 6500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 6500, ICHAIN_STOP),
 };
 
 void EnOkuta_Init(Actor* thisx, PlayState* play2) {
diff --git a/src/overlays/actors/ovl_En_Ossan/z_en_ossan.c b/src/overlays/actors/ovl_En_Ossan/z_en_ossan.c
index f468a8ca85..76370338be 100644
--- a/src/overlays/actors/ovl_En_Ossan/z_en_ossan.c
+++ b/src/overlays/actors/ovl_En_Ossan/z_en_ossan.c
@@ -186,7 +186,7 @@ static u16 sBuySuccessTextIds[] = { 0x06BF, 0x06DC };
 static u16 sCannotGetNowTextIds[] = { 0x06C0, 0x06DD };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 500, ICHAIN_STOP),
 };
 
 void EnOssan_SetupAction(EnOssan* this, EnOssanActionFunc action) {
diff --git a/src/overlays/actors/ovl_En_Owl/z_en_owl.c b/src/overlays/actors/ovl_En_Owl/z_en_owl.c
index 287dbfe5f2..034832330d 100644
--- a/src/overlays/actors/ovl_En_Owl/z_en_owl.c
+++ b/src/overlays/actors/ovl_En_Owl/z_en_owl.c
@@ -134,7 +134,7 @@ void EnOwl_Init(Actor* thisx, PlayState* play) {
     Collider_InitAndSetCylinder(play, &this->collider, &this->actor, &sCylinderInit);
     this->actor.colChkInfo.mass = MASS_IMMOVABLE;
     this->actor.terminalVelocity = -10.0f;
-    this->actor.targetArrowOffset = 500.0f;
+    this->actor.lockOnArrowOffset = 500.0f;
     EnOwl_ChangeMode(this, func_8095BF58, func_8095C484, &this->skelAnimePerching, &gOwlPerchAnim, 0.0f);
 
     this->actionFlags = 0;
diff --git a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
index bc9a0dfd56..25bc240020 100644
--- a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
+++ b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
@@ -166,7 +166,7 @@ static CollisionCheckInfoInit sColChkInit = { 3, 30, 60, 50 };
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_GEKKO_SNAPPER, ICHAIN_CONTINUE),
-    ICHAIN_F32_DIV1000(targetArrowOffset, -13221, ICHAIN_CONTINUE),
+    ICHAIN_F32_DIV1000(lockOnArrowOffset, -13221, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -1000, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 7, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_10, ICHAIN_STOP),
diff --git a/src/overlays/actors/ovl_En_Peehat/z_en_peehat.c b/src/overlays/actors/ovl_En_Peehat/z_en_peehat.c
index 03253101a8..8e95899a57 100644
--- a/src/overlays/actors/ovl_En_Peehat/z_en_peehat.c
+++ b/src/overlays/actors/ovl_En_Peehat/z_en_peehat.c
@@ -171,7 +171,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 4200, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneScale, 800, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneDownward, 1800, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 700, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 700, ICHAIN_STOP),
 };
 
 void EnPeehat_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Po_Composer/z_en_po_composer.c b/src/overlays/actors/ovl_En_Po_Composer/z_en_po_composer.c
index 61a3ef818b..be88f36fd6 100644
--- a/src/overlays/actors/ovl_En_Po_Composer/z_en_po_composer.c
+++ b/src/overlays/actors/ovl_En_Po_Composer/z_en_po_composer.c
@@ -176,7 +176,7 @@ static Color_RGBA8 sSharpClothingColor2 = { 90, 85, 50, 255 };
 static Color_RGBA8 sFlatClothingColor2 = { 100, 90, 100, 255 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 3200, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 3200, ICHAIN_STOP),
 };
 
 static s32 sPlayerIsPlayingOcarina = false;
diff --git a/src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c b/src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c
index d7b610c899..470fdc9979 100644
--- a/src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c
+++ b/src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c
@@ -143,7 +143,7 @@ static DamageTable sDamageTable = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_VEC3F_DIV1000(scale, 7, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 6000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 6000, ICHAIN_STOP),
 };
 
 // clang-format off
diff --git a/src/overlays/actors/ovl_En_Poh/z_en_poh.c b/src/overlays/actors/ovl_En_Poh/z_en_poh.c
index 662a4e58ce..0e1b968348 100644
--- a/src/overlays/actors/ovl_En_Poh/z_en_poh.c
+++ b/src/overlays/actors/ovl_En_Poh/z_en_poh.c
@@ -145,7 +145,7 @@ static CollisionCheckInfoInit sColChkInfoInit = { 3, 25, 50, 50 };
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_POE, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 3200, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 3200, ICHAIN_STOP),
 };
 
 void EnPoh_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Rail_Skb/z_en_rail_skb.c b/src/overlays/actors/ovl_En_Rail_Skb/z_en_rail_skb.c
index 1158c4156d..f608a1c8ae 100644
--- a/src/overlays/actors/ovl_En_Rail_Skb/z_en_rail_skb.c
+++ b/src/overlays/actors/ovl_En_Rail_Skb/z_en_rail_skb.c
@@ -279,7 +279,7 @@ void func_80B70D24(EnRailSkb* this, PlayState* play) {
 }
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Railgibud/z_en_railgibud.c b/src/overlays/actors/ovl_En_Railgibud/z_en_railgibud.c
index 5a08d6e5c4..575573e028 100644
--- a/src/overlays/actors/ovl_En_Railgibud/z_en_railgibud.c
+++ b/src/overlays/actors/ovl_En_Railgibud/z_en_railgibud.c
@@ -237,7 +237,7 @@ void EnRailgibud_SpawnOtherGibdosAndSetPositionAndRotation(EnRailgibud* this, Pl
 }
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 10, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -3500, ICHAIN_STOP),
 };
diff --git a/src/overlays/actors/ovl_En_Rat/z_en_rat.c b/src/overlays/actors/ovl_En_Rat/z_en_rat.c
index e12786a04d..ca77bb9707 100644
--- a/src/overlays/actors/ovl_En_Rat/z_en_rat.c
+++ b/src/overlays/actors/ovl_En_Rat/z_en_rat.c
@@ -120,7 +120,7 @@ static TexturePtr sSparkTextures[] = {
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_REAL_BOMBCHU, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 15, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 5000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 5000, ICHAIN_STOP),
 };
 
 static EffectBlureInit2 sBlureInit = {
diff --git a/src/overlays/actors/ovl_En_Rd/z_en_rd.c b/src/overlays/actors/ovl_En_Rd/z_en_rd.c
index 9ec85d1b6b..e76c0e0959 100644
--- a/src/overlays/actors/ovl_En_Rd/z_en_rd.c
+++ b/src/overlays/actors/ovl_En_Rd/z_en_rd.c
@@ -180,7 +180,7 @@ static DamageTable sDamageTable = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 10, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -3500, ICHAIN_STOP),
 };
diff --git a/src/overlays/actors/ovl_En_Recepgirl/z_en_recepgirl.c b/src/overlays/actors/ovl_En_Recepgirl/z_en_recepgirl.c
index f6c133abb0..4327ace0c8 100644
--- a/src/overlays/actors/ovl_En_Recepgirl/z_en_recepgirl.c
+++ b/src/overlays/actors/ovl_En_Recepgirl/z_en_recepgirl.c
@@ -41,7 +41,7 @@ static TexturePtr sEyeTextures[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_6, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1000, ICHAIN_STOP),
 };
 
 static s32 sTexturesDesegmented = false;
diff --git a/src/overlays/actors/ovl_En_Rr/z_en_rr.c b/src/overlays/actors/ovl_En_Rr/z_en_rr.c
index 0375edb1a5..bc066051d8 100644
--- a/src/overlays/actors/ovl_En_Rr/z_en_rr.c
+++ b/src/overlays/actors/ovl_En_Rr/z_en_rr.c
@@ -123,7 +123,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_2, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -400, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneForward, 2000, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 30, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 30, ICHAIN_STOP),
 };
 
 void EnRr_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Ruppecrow/z_en_ruppecrow.c b/src/overlays/actors/ovl_En_Ruppecrow/z_en_ruppecrow.c
index 235181bff6..8aa7df6696 100644
--- a/src/overlays/actors/ovl_En_Ruppecrow/z_en_ruppecrow.c
+++ b/src/overlays/actors/ovl_En_Ruppecrow/z_en_ruppecrow.c
@@ -105,7 +105,7 @@ static DamageTable sDamageTable = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_F32_DIV1000(gravity, -500, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_STOP),
 };
 
 s32 EnRuppecrow_UpdateCollision(EnRuppecrow* this, PlayState* play) {
@@ -442,7 +442,7 @@ void EnRuppecrow_HandleDeath(EnRuppecrow* this) {
     Animation_Change(&this->skelAnime, &gGuayFlyAnim, 0.4f, 0.0f, 0.0f, ANIMMODE_LOOP_INTERP, -3.0f);
 
     this->actor.shape.yOffset = 0.0f;
-    this->actor.targetArrowOffset = 0.0f;
+    this->actor.lockOnArrowOffset = 0.0f;
     this->actor.bgCheckFlags &= ~BGCHECKFLAG_GROUND;
 
     scale = this->actor.scale.x * 100.0f;
diff --git a/src/overlays/actors/ovl_En_Sb/z_en_sb.c b/src/overlays/actors/ovl_En_Sb/z_en_sb.c
index 4e4edf8af8..c4bf42c070 100644
--- a/src/overlays/actors/ovl_En_Sb/z_en_sb.c
+++ b/src/overlays/actors/ovl_En_Sb/z_en_sb.c
@@ -94,7 +94,7 @@ static DamageTable sDamageTable = {
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_SHELLBLADE, ICHAIN_CONTINUE),
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_2, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 30, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 30, ICHAIN_STOP),
 };
 
 static Vec3f sFlamePosOffsets[] = {
diff --git a/src/overlays/actors/ovl_En_Scopenuts/z_en_scopenuts.c b/src/overlays/actors/ovl_En_Scopenuts/z_en_scopenuts.c
index 1d9c986b62..c6d57bd3b8 100644
--- a/src/overlays/actors/ovl_En_Scopenuts/z_en_scopenuts.c
+++ b/src/overlays/actors/ovl_En_Scopenuts/z_en_scopenuts.c
@@ -123,7 +123,7 @@ Vec3f D_80BCCCE4 = { 0.0f, -0.5f, 0.0f };
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_0, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 30, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 30, ICHAIN_STOP),
 };
 
 s16 func_80BCABF0(Path* path) {
diff --git a/src/overlays/actors/ovl_En_Sellnuts/z_en_sellnuts.c b/src/overlays/actors/ovl_En_Sellnuts/z_en_sellnuts.c
index d5b007cd9d..6c5ee46148 100644
--- a/src/overlays/actors/ovl_En_Sellnuts/z_en_sellnuts.c
+++ b/src/overlays/actors/ovl_En_Sellnuts/z_en_sellnuts.c
@@ -135,7 +135,7 @@ static AnimationInfoS sAnimationInfo[ENSELLNUTS_ANIM_MAX] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_0, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 30, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 30, ICHAIN_STOP),
 };
 
 void func_80ADADD0(EnSellnuts* this, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Skb/z_en_skb.c b/src/overlays/actors/ovl_En_Skb/z_en_skb.c
index 8e01f177ee..d44c8e62dc 100644
--- a/src/overlays/actors/ovl_En_Skb/z_en_skb.c
+++ b/src/overlays/actors/ovl_En_Skb/z_en_skb.c
@@ -222,7 +222,7 @@ void func_80994A9C(EnSkb* this, PlayState* play) {
 }
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_STOP),
 };
 
@@ -482,7 +482,7 @@ void func_809954F8(EnSkb* this) {
     this->actor.shape.shadowScale = 0.0f;
     this->actor.speed = 0.0f;
     this->actor.shape.yOffset = 0.0f;
-    this->actor.targetArrowOffset = 4000.0f;
+    this->actor.lockOnArrowOffset = 4000.0f;
 }
 
 void func_8099556C(EnSkb* this, PlayState* play) {
@@ -507,7 +507,7 @@ void func_8099556C(EnSkb* this, PlayState* play) {
                (this->skelAnime.curFrame > 24.0f) && (this->skelAnime.curFrame < 28.0f)) {
         this->actor.hintId = TATL_HINT_ID_STALCHILD;
         this->actor.colChkInfo.mass = MASS_HEAVY;
-        this->actor.targetArrowOffset = 2000.0f;
+        this->actor.lockOnArrowOffset = 2000.0f;
         func_8099571C(this);
     }
 }
diff --git a/src/overlays/actors/ovl_En_Slime/z_en_slime.c b/src/overlays/actors/ovl_En_Slime/z_en_slime.c
index c6775923f8..f251802425 100644
--- a/src/overlays/actors/ovl_En_Slime/z_en_slime.c
+++ b/src/overlays/actors/ovl_En_Slime/z_en_slime.c
@@ -144,7 +144,7 @@ static TexturePtr sEyeTextures[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_F32(gravity, -2, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 6000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 6000, ICHAIN_STOP),
 };
 
 static s32 sTexturesDesegmented = false;
@@ -1093,7 +1093,7 @@ void EnSlime_Update(Actor* thisx, PlayState* play) {
     thisx->shape.shadowAlpha = this->iceBlockTimer;
     if (this->iceBlockTimer == ICE_BLOCK_UNUSED) {
         if (thisx->scale.y > 0.0001f) {
-            thisx->targetArrowOffset = 60.0f / thisx->scale.y;
+            thisx->lockOnArrowOffset = 60.0f / thisx->scale.y;
         }
 
         if (this->collider.base.ocFlags1 & OC1_ON) {
diff --git a/src/overlays/actors/ovl_En_Snowman/z_en_snowman.c b/src/overlays/actors/ovl_En_Snowman/z_en_snowman.c
index ca2dd8c9e6..dc1fb02569 100644
--- a/src/overlays/actors/ovl_En_Snowman/z_en_snowman.c
+++ b/src/overlays/actors/ovl_En_Snowman/z_en_snowman.c
@@ -180,7 +180,7 @@ static Gfx* sSnowballFragmentDLs[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_EENO, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 3000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 3000, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -1000, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Sob1/z_en_sob1.c b/src/overlays/actors/ovl_En_Sob1/z_en_sob1.c
index c98ab78d74..20840d3aa9 100644
--- a/src/overlays/actors/ovl_En_Sob1/z_en_sob1.c
+++ b/src/overlays/actors/ovl_En_Sob1/z_en_sob1.c
@@ -139,7 +139,7 @@ static Vec3f sSelectedItemPositions[] = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 500, ICHAIN_STOP),
 };
 
 static EnSob1ActionFunc sInitFuncs[] = {
diff --git a/src/overlays/actors/ovl_En_Syateki_Crow/z_en_syateki_crow.c b/src/overlays/actors/ovl_En_Syateki_Crow/z_en_syateki_crow.c
index 92c2027dbb..e219435495 100644
--- a/src/overlays/actors/ovl_En_Syateki_Crow/z_en_syateki_crow.c
+++ b/src/overlays/actors/ovl_En_Syateki_Crow/z_en_syateki_crow.c
@@ -68,7 +68,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_F32(uncullZoneScale, 3000, ICHAIN_CONTINUE),
     ICHAIN_S8(hintId, TATL_HINT_ID_GUAY, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -500, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_STOP),
 };
 
 void EnSyatekiCrow_Init(Actor* thisx, PlayState* play2) {
diff --git a/src/overlays/actors/ovl_En_Syateki_Dekunuts/z_en_syateki_dekunuts.c b/src/overlays/actors/ovl_En_Syateki_Dekunuts/z_en_syateki_dekunuts.c
index 16ed15f3ce..513f9b4000 100644
--- a/src/overlays/actors/ovl_En_Syateki_Dekunuts/z_en_syateki_dekunuts.c
+++ b/src/overlays/actors/ovl_En_Syateki_Dekunuts/z_en_syateki_dekunuts.c
@@ -97,7 +97,7 @@ static AnimationInfo sAnimationInfo[SG_DEKU_ANIM_MAX] = {
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_MAD_SCRUB, ICHAIN_CONTINUE),
     ICHAIN_F32(gravity, 0, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2600, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 2600, ICHAIN_STOP),
 };
 
 void EnSyatekiDekunuts_Init(Actor* thisx, PlayState* play2) {
diff --git a/src/overlays/actors/ovl_En_Syateki_Okuta/z_en_syateki_okuta.c b/src/overlays/actors/ovl_En_Syateki_Okuta/z_en_syateki_okuta.c
index 8ce41601b9..0e538cc353 100644
--- a/src/overlays/actors/ovl_En_Syateki_Okuta/z_en_syateki_okuta.c
+++ b/src/overlays/actors/ovl_En_Syateki_Okuta/z_en_syateki_okuta.c
@@ -83,7 +83,7 @@ static AnimationInfo sAnimationInfo[SG_OCTO_ANIM_MAX] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_OCTOROK, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 6500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 6500, ICHAIN_STOP),
 };
 
 void EnSyatekiOkuta_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Syateki_Wf/z_en_syateki_wf.c b/src/overlays/actors/ovl_En_Syateki_Wf/z_en_syateki_wf.c
index e1044c15b7..ff91070eeb 100644
--- a/src/overlays/actors/ovl_En_Syateki_Wf/z_en_syateki_wf.c
+++ b/src/overlays/actors/ovl_En_Syateki_Wf/z_en_syateki_wf.c
@@ -135,7 +135,7 @@ static AnimationInfo sAnimationInfo[SG_WOLFOS_ANIM_MAX] = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Takaraya/z_en_takaraya.c b/src/overlays/actors/ovl_En_Takaraya/z_en_takaraya.c
index a5d81d792b..f56534f4cc 100644
--- a/src/overlays/actors/ovl_En_Takaraya/z_en_takaraya.c
+++ b/src/overlays/actors/ovl_En_Takaraya/z_en_takaraya.c
@@ -59,7 +59,7 @@ TexturePtr sEyesDownTextures[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_6, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1000, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 1000, ICHAIN_STOP),
 };
 
 static s32 sTexturesDesegmented = false;
diff --git a/src/overlays/actors/ovl_En_Talk/z_en_talk.c b/src/overlays/actors/ovl_En_Talk/z_en_talk.c
index 7a129a0ffa..781baa8d90 100644
--- a/src/overlays/actors/ovl_En_Talk/z_en_talk.c
+++ b/src/overlays/actors/ovl_En_Talk/z_en_talk.c
@@ -30,7 +30,7 @@ ActorProfile En_Talk_Profile = {
 
 void EnTalk_Init(Actor* thisx, PlayState* play) {
     EnTalk* this = THIS;
-    s8 attentionRangeType = ENTALK_GET_TARGET_MODE(&this->actor);
+    s8 attentionRangeType = ENTALK_GET_ATTENTION_RANGE_TYPE(&this->actor);
 
     if ((attentionRangeType >= ATTENTION_RANGE_0) && (attentionRangeType < ATTENTION_RANGE_7)) {
         this->actor.attentionRangeType = attentionRangeType;
diff --git a/src/overlays/actors/ovl_En_Talk/z_en_talk.h b/src/overlays/actors/ovl_En_Talk/z_en_talk.h
index a97637e4eb..b27ab03c87 100644
--- a/src/overlays/actors/ovl_En_Talk/z_en_talk.h
+++ b/src/overlays/actors/ovl_En_Talk/z_en_talk.h
@@ -4,7 +4,7 @@
 #include "global.h"
 
 #define ENTALK_GET_TEXT_ID(thisx) (((thisx)->params & 0x3F) + 0x1C00)
-#define ENTALK_GET_TARGET_MODE(thisx) (((thisx)->home.rot.x) - 1)
+#define ENTALK_GET_ATTENTION_RANGE_TYPE(thisx) (((thisx)->home.rot.x) - 1)
 
 struct EnTalk;
 
diff --git a/src/overlays/actors/ovl_En_Talk_Gibud/z_en_talk_gibud.c b/src/overlays/actors/ovl_En_Talk_Gibud/z_en_talk_gibud.c
index 6824a94a8f..5f7a803563 100644
--- a/src/overlays/actors/ovl_En_Talk_Gibud/z_en_talk_gibud.c
+++ b/src/overlays/actors/ovl_En_Talk_Gibud/z_en_talk_gibud.c
@@ -214,7 +214,7 @@ static EnTalkGibudRequestedItem sRequestedItemTable[] = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_VEC3F_DIV1000(scale, 10, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -3500, ICHAIN_STOP),
 };
diff --git a/src/overlays/actors/ovl_En_Tanron2/z_en_tanron2.c b/src/overlays/actors/ovl_En_Tanron2/z_en_tanron2.c
index 2a7418d598..99ecaf24fa 100644
--- a/src/overlays/actors/ovl_En_Tanron2/z_en_tanron2.c
+++ b/src/overlays/actors/ovl_En_Tanron2/z_en_tanron2.c
@@ -431,7 +431,7 @@ void func_80BB7578(EnTanron2* this, PlayState* play) {
                 Actor_PlaySfx(&this->actor, NA_SE_EN_IKURA_DAMAGE);
                 if ((player->focusActor != NULL) && (&this->actor != player->focusActor)) {
                     player->focusActor = &this->actor;
-                    play->actorCtx.attention.fairyActor = &this->actor;
+                    play->actorCtx.attention.tatlHoverActor = &this->actor;
                     play->actorCtx.attention.reticleActor = &this->actor;
                 }
             } else {
diff --git a/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c b/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c
index 5b5abdc3f8..8e35524948 100644
--- a/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c
+++ b/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c
@@ -140,7 +140,7 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_F32(uncullZoneForward, 3000, ICHAIN_CONTINUE),
     ICHAIN_F32(uncullZoneScale, 1000, ICHAIN_CONTINUE),
     ICHAIN_S8(hintId, TATL_HINT_ID_TAKKURI, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 500, ICHAIN_STOP),
 };
 
 Vec3f D_80C13920;
diff --git a/src/overlays/actors/ovl_En_Tite/z_en_tite.c b/src/overlays/actors/ovl_En_Tite/z_en_tite.c
index 5addcc6eb3..7d919018a1 100644
--- a/src/overlays/actors/ovl_En_Tite/z_en_tite.c
+++ b/src/overlays/actors/ovl_En_Tite/z_en_tite.c
@@ -126,7 +126,7 @@ static Vec3f D_80896B44 = { 0.0f, 0.45f, 0.0f };
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_BLUE_TEKTITE, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_F32(terminalVelocity, -40, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -1000, ICHAIN_STOP),
 };
diff --git a/src/overlays/actors/ovl_En_Tk/z_en_tk.c b/src/overlays/actors/ovl_En_Tk/z_en_tk.c
index 5565ad1798..25408915b0 100644
--- a/src/overlays/actors/ovl_En_Tk/z_en_tk.c
+++ b/src/overlays/actors/ovl_En_Tk/z_en_tk.c
@@ -1111,7 +1111,7 @@ s32 func_80AEEA4C(EnTk* this, PlayState* play) {
         ret = 3;
     } else if (this->actor.xyzDistToPlayerSq < SQ(60.0f)) {
         ret = 0;
-    } else if (this->actor.isLockedOn || (play->actorCtx.attention.arrowPointedActor == &this->actor) ||
+    } else if (this->actor.isLockedOn || (play->actorCtx.attention.arrowHoverActor == &this->actor) ||
                (this->actor.xyzDistToPlayerSq < SQ(80.0f))) {
         ret = 1;
     } else {
diff --git a/src/overlays/actors/ovl_En_Trt/z_en_trt.c b/src/overlays/actors/ovl_En_Trt/z_en_trt.c
index 7903fb3853..3bbead826a 100644
--- a/src/overlays/actors/ovl_En_Trt/z_en_trt.c
+++ b/src/overlays/actors/ovl_En_Trt/z_en_trt.c
@@ -1702,7 +1702,7 @@ void EnTrt_DrawStickDirectionPrompt(PlayState* play, EnTrt* this) {
 }
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 500, ICHAIN_STOP),
 };
 
 void EnTrt_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Trt2/z_en_trt2.c b/src/overlays/actors/ovl_En_Trt2/z_en_trt2.c
index 82b7bb756d..fdef394246 100644
--- a/src/overlays/actors/ovl_En_Trt2/z_en_trt2.c
+++ b/src/overlays/actors/ovl_En_Trt2/z_en_trt2.c
@@ -801,7 +801,7 @@ void func_80AD4FE4(EnTrt2* this, PlayState* play) {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_3, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 500, ICHAIN_STOP),
 };
 
 void EnTrt2_Init(Actor* thisx, PlayState* play) {
diff --git a/src/overlays/actors/ovl_En_Vm/z_en_vm.c b/src/overlays/actors/ovl_En_Vm/z_en_vm.c
index 5cbcc0a0e6..bfb1d42a8a 100644
--- a/src/overlays/actors/ovl_En_Vm/z_en_vm.c
+++ b/src/overlays/actors/ovl_En_Vm/z_en_vm.c
@@ -150,7 +150,7 @@ TexturePtr D_808CD58C[] = {
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_VEC3F_DIV1000(scale, 14, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 1000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 1000, ICHAIN_CONTINUE),
     ICHAIN_S8(hintId, TATL_HINT_ID_BEAMOS, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Wallmas/z_en_wallmas.c b/src/overlays/actors/ovl_En_Wallmas/z_en_wallmas.c
index ffa86afd3c..a2f095d4ed 100644
--- a/src/overlays/actors/ovl_En_Wallmas/z_en_wallmas.c
+++ b/src/overlays/actors/ovl_En_Wallmas/z_en_wallmas.c
@@ -126,7 +126,7 @@ static CollisionCheckInfoInit sColChkInfoInit = { 3, 30, 40, 150 };
 
 static InitChainEntry sInitChain[] = {
     ICHAIN_S8(hintId, TATL_HINT_ID_WALLMASTER, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 5500, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 5500, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -1500, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Wf/z_en_wf.c b/src/overlays/actors/ovl_En_Wf/z_en_wf.c
index 49ff543f21..fc74a2ee6c 100644
--- a/src/overlays/actors/ovl_En_Wf/z_en_wf.c
+++ b/src/overlays/actors/ovl_En_Wf/z_en_wf.c
@@ -255,7 +255,7 @@ static TexturePtr sWhiteEyeTextures[] = {
 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 2000, ICHAIN_CONTINUE),
+    ICHAIN_F32(lockOnArrowOffset, 2000, ICHAIN_CONTINUE),
     ICHAIN_F32_DIV1000(gravity, -2000, ICHAIN_STOP),
 };
 
diff --git a/src/overlays/actors/ovl_En_Wood02/z_en_wood02.c b/src/overlays/actors/ovl_En_Wood02/z_en_wood02.c
index 5131008a62..c6a8c0db2d 100644
--- a/src/overlays/actors/ovl_En_Wood02/z_en_wood02.c
+++ b/src/overlays/actors/ovl_En_Wood02/z_en_wood02.c
@@ -77,7 +77,7 @@ f32 sWood02SpawnDistance[] = { 707.0f, 525.0f, 510.0f, 500.0f, 566.0f, 141.0f };
 s16 sWood02SpawnAngle[] = { 0x1FFF, 0x4C9E, 0x77F5, 0xA5C9, -0x293D, 0xA000 };
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 5600, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 5600, ICHAIN_STOP),
 };
 
 Gfx* D_808C4D54[] = {
diff --git a/src/overlays/actors/ovl_En_Zl4/z_en_zl4.c b/src/overlays/actors/ovl_En_Zl4/z_en_zl4.c
index 407fb4b290..49b9da96ec 100644
--- a/src/overlays/actors/ovl_En_Zl4/z_en_zl4.c
+++ b/src/overlays/actors/ovl_En_Zl4/z_en_zl4.c
@@ -60,7 +60,7 @@ void EnZl4_Init(Actor* thisx, PlayState* play) {
 
     this->unk_2E0 = 0;
     this->alpha = 255;
-    this->actor.targetArrowOffset = 3000.0f;
+    this->actor.lockOnArrowOffset = 3000.0f;
     ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 24.0f);
     SkelAnime_InitFlex(play, &this->skelAnime, &gSkullKidSkel, NULL, NULL, NULL, 0);
     EnZl4_ChangeAnim(&this->skelAnime, &sAnimationInfo[ENZL4_ANIM_T_POSE], 0);
diff --git a/src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c b/src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c
index f2047f7098..45b05e2c9e 100644
--- a/src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c
+++ b/src/overlays/actors/ovl_Obj_Ghaka/z_obj_ghaka.c
@@ -40,7 +40,7 @@ static Vec3f D_80B3C960 = { 0.0f, 0.0f, 0.0f };
 
 static InitChainEntry D_80B3C96C[] = {
     ICHAIN_U8(attentionRangeType, ATTENTION_RANGE_0, ICHAIN_CONTINUE),
-    ICHAIN_F32(targetArrowOffset, 30, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 30, ICHAIN_STOP),
 };
 
 void func_80B3C260(ObjGhaka* this) {
diff --git a/src/overlays/actors/ovl_Obj_Snowball/z_obj_snowball.c b/src/overlays/actors/ovl_Obj_Snowball/z_obj_snowball.c
index d77dbc3416..9eefab99da 100644
--- a/src/overlays/actors/ovl_Obj_Snowball/z_obj_snowball.c
+++ b/src/overlays/actors/ovl_Obj_Snowball/z_obj_snowball.c
@@ -479,7 +479,7 @@ void ObjSnowball_Init(Actor* thisx, PlayState* play) {
     if (sp34) {
         this->actor.textId = 0x238;
         this->actor.flags |= ACTOR_FLAG_ATTENTION_ENABLED;
-        this->actor.targetArrowOffset = 1400.0f / 3.0f;
+        this->actor.lockOnArrowOffset = 1400.0f / 3.0f;
         Actor_SetFocus(&this->actor, 24.0f);
         this->actor.attentionRangeType = ATTENTION_RANGE_3;
     }
diff --git a/src/overlays/actors/ovl_player_actor/z_player.c b/src/overlays/actors/ovl_player_actor/z_player.c
index 8e54dfed1d..305bf22095 100644
--- a/src/overlays/actors/ovl_player_actor/z_player.c
+++ b/src/overlays/actors/ovl_player_actor/z_player.c
@@ -4918,19 +4918,20 @@ void func_80832888(Player* this, PlayState* play) {
             if (!(this->stateFlags1 & PLAYER_STATE1_2000000) &&
                 ((this->heldItemAction != PLAYER_IA_FISHING_ROD) || (this->unk_B28 == 0)) &&
                 CHECK_BTN_ALL(sPlayerControlInput->press.button, BTN_Z)) {
-                var_v1_2 = (this == GET_PLAYER(play)) ? play->actorCtx.attention.fairyActor : &GET_PLAYER(play)->actor;
+                var_v1_2 =
+                    (this == GET_PLAYER(play)) ? play->actorCtx.attention.tatlHoverActor : &GET_PLAYER(play)->actor;
                 var_a1 = (gSaveContext.options.zTargetSetting != 0) || (this != GET_PLAYER(play));
                 this->stateFlags1 |= PLAYER_STATE1_8000;
                 if ((this->currentMask != PLAYER_MASK_GIANT) && (var_v1_2 != NULL) &&
                     !(var_v1_2->flags & ACTOR_FLAG_LOCK_ON_DISABLED) &&
                     !(this->stateFlags3 & (PLAYER_STATE3_200 | PLAYER_STATE3_2000))) {
                     if ((var_v1_2 == this->focusActor) && (this == GET_PLAYER(play))) {
-                        var_v1_2 = play->actorCtx.attention.arrowPointedActor;
+                        var_v1_2 = play->actorCtx.attention.arrowHoverActor;
                     }
 
                     if ((var_v1_2 != NULL) &&
-                        (((var_v1_2 != this->focusActor)) || (var_v1_2->flags & ACTOR_FLAG_80000))) {
-                        var_v1_2->flags &= ~ACTOR_FLAG_80000;
+                        (((var_v1_2 != this->focusActor)) || (var_v1_2->flags & ACTOR_FLAG_FOCUS_ACTOR_REFINDABLE))) {
+                        var_v1_2->flags &= ~ACTOR_FLAG_FOCUS_ACTOR_REFINDABLE;
                         if (!var_a1) {
                             this->stateFlags2 |= PLAYER_STATE2_LOCK_ON_WITH_SWITCH;
                         }
@@ -4949,7 +4950,7 @@ void func_80832888(Player* this, PlayState* play) {
 
             if (this->focusActor != NULL) {
                 if ((this == GET_PLAYER(play)) && (this->focusActor != this->autoLockOnActor) &&
-                    Attention_OutsideLeashRange(this->focusActor, this, ignoreLeash)) {
+                    Attention_ShouldReleaseLockOn(this->focusActor, this, ignoreLeash)) {
                     Player_ReleaseLockOn(this);
                     this->stateFlags1 |= PLAYER_STATE1_40000000;
                 } else if (this->focusActor != NULL) {
@@ -10840,7 +10841,7 @@ void func_80841744(PlayState* play, Player* this) {
 }
 
 static InitChainEntry sInitChain[] = {
-    ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
+    ICHAIN_F32(lockOnArrowOffset, 500, ICHAIN_STOP),
 };
 
 Vec3s sPlayerSkeletonBaseTransl = { -57, 3377, 0 };
@@ -11415,7 +11416,7 @@ void Player_SetDoAction(PlayState* play, Player* this) {
                             (this->transformation == PLAYER_FORM_ZORA)) &&
                            ((this->heldItemAction >= PLAYER_IA_SWORD_KOKIRI) ||
                             ((this->stateFlags2 & PLAYER_STATE2_100000) &&
-                             (play->actorCtx.attention.fairyActor == NULL)))) {
+                             (play->actorCtx.attention.tatlHoverActor == NULL)))) {
                     doActionA = DO_ACTION_PUTAWAY;
 
                     if (play->msgCtx.currentTextId == 0) {} //! FAKE
diff --git a/tools/disasm/functions.txt b/tools/disasm/functions.txt
index d8ae53df5a..31f9cac0c1 100644
--- a/tools/disasm/functions.txt
+++ b/tools/disasm/functions.txt
@@ -671,7 +671,7 @@
     0x800B4EDC:("Actor_GetProjectedPos",),
     0x800B4F40:("Attention_SetReticlePos",),
     0x800B4F78:("Attention_InitReticle",),
-    0x800B5040:("Attention_SetFairyState",),
+    0x800B5040:("Attention_SetTatlState",),
     0x800B51A4:("Attention_Init",),
     0x800B5208:("Attention_Draw",),
     0x800B5814:("Attention_Update",),
@@ -766,9 +766,9 @@
     0x800B81E0:("Actor_GetFocus",),
     0x800B8214:("Actor_GetWorld",),
     0x800B8248:("Actor_GetWorldPosShapeRot",),
-    0x800B82EC:("Attention_GetAdjustedDistSq",),
-    0x800B83BC:("Attention_IsActorInRange",),
-    0x800B83F8:("Attention_OutsideLeashRange",),
+    0x800B82EC:("Attention_WeightedDistToPlayerSq",),
+    0x800B83BC:("Attention_ActorIsInRange",),
+    0x800B83F8:("Attention_ShouldReleaseLockOn",),
     0x800B84D0:("Actor_TalkOfferAccepted",),
     0x800B8500:("Actor_OfferTalkExchange",),
     0x800B85E0:("Actor_OfferTalkExchangeEquiCylinder",),
@@ -840,9 +840,9 @@
     0x800BB140:("Actor_SpawnTransitionActors",),
     0x800BB2D0:("Actor_SpawnEntry",),
     0x800BB498:("Actor_Delete",),
-    0x800BB59C:("Attention_InTargetableScreenRegion",),
-    0x800BB604:("Attention_FindTargetableActorForCategory",),
-    0x800BB8EC:("Attention_GetTargetActor",),
+    0x800BB59C:("Attention_ActorOnScreen",),
+    0x800BB604:("Attention_FindActorInCategory",),
+    0x800BB8EC:("Attention_FindActor",),
     0x800BBA88:("Enemy_StartFinishingBlow",),
     0x800BBAC0:("func_800BBAC0",),
     0x800BBB74:("func_800BBB74",),
@@ -1169,7 +1169,7 @@
     0x800CD3E4:("Camera_BgCheckCorner",),
     0x800CD44C:("func_800CD44C",),
     0x800CD634:("Camera_CalcSlopeYAdj",),
-    0x800CD6CC:("func_800CD6CC",),
+    0x800CD6CC:("Camera_GetAttentionActorRange",),
     0x800CD6F8:("Camera_CalcAtDefault",),
     0x800CD834:("Camera_CalcAtForScreen",),
     0x800CDA14:("Camera_CalcAtForNormal1",),
diff --git a/tools/disasm/variables.txt b/tools/disasm/variables.txt
index f619532565..53ae489191 100644
--- a/tools/disasm/variables.txt
+++ b/tools/disasm/variables.txt
@@ -419,13 +419,13 @@
     0x801AEC74:("sCurrentBit","u32","",0x4),
     0x801AEC78:("sTimer","s32","",0x4),
     0x801AEC80:("D_801AEC80","Color_RGBA8","",0x4),
-    0x801AEC84:("sTatlColorList","TatlColor","[13]",0x68),
+    0x801AEC84:("sAttentionColors","TatlColor","[13]",0x68),
     0x801AECEC:("sActorMovementScale","f32","",0x4),
     0x801AECF0:("gAttentionRanges","f32","[]",0x58),
     0x801AED48:("D_801AED48","s16","[8]",0x10),
     0x801AED58:("sCategoryFreezeMasks","UNK_TYPE4","",0x4),
     0x801AED88:("actorDefaultHitColor","Color_RGBA8","",0x4),
-    0x801AED8C:("sTargetableActorCategories","UNK_TYPE1","",0x1),
+    0x801AED8C:("sAttentionCategorySearchOrder","UNK_TYPE1","",0x1),
     0x801AED98:("D_801AED98","Vec3f","",0xC),
     0x801AEDA4:("D_801AEDA4","UNK_TYPE4","",0x4),
     0x801AEDB0:("sArrowDmgFlags","UNK_TYPE1","",0x1),
@@ -3744,18 +3744,18 @@
     0x801ED8A0:("sActorFaultClient","UNK_TYPE1","",0x1),
     0x801ED8B0:("D_801ED8B0","UNK_TYPE1","",0x1),
     0x801ED8B4:("D_801ED8B4","UNK_TYPE1","",0x1),
-    0x801ED8B8:("sTargetableNearestActor","UNK_TYPE1","",0x1),
-    0x801ED8BC:("sTargetablePrioritizedActor","UNK_TYPE1","",0x1),
-    0x801ED8C0:("D_801ED8C0","UNK_TYPE1","",0x1),
-    0x801ED8C4:("D_801ED8C4","UNK_TYPE1","",0x1),
-    0x801ED8C8:("sTargetableNearestActorDistSq","f32","",0x4),
+    0x801ED8B8:("sNearestAttentionActor","UNK_TYPE1","",0x1),
+    0x801ED8BC:("sPrioritizedAttentionActor","UNK_TYPE1","",0x1),
+    0x801ED8C0:("sNearestCameraDriftActor","UNK_TYPE1","",0x1),
+    0x801ED8C4:("sPrioritizedCameraDriftActor","UNK_TYPE1","",0x1),
+    0x801ED8C8:("sNearestAttentionActorDistSq","f32","",0x4),
     0x801ED8CC:("sBgmEnemyDistSq","f32","",0x4),
-    0x801ED8D0:("D_801ED8D0","f32","",0x4),
-    0x801ED8D4:("sTargetablePrioritizedPriority","UNK_TYPE1","",0x1),
-    0x801ED8D8:("D_801ED8D8","UNK_TYPE1","",0x1),
-    0x801ED8DC:("sTargetPlayerRotY","UNK_TYPE1","",0x1),
+    0x801ED8D0:("sNearestCameraDriftActorDistSq","f32","",0x4),
+    0x801ED8D4:("sHighestAttentionPriority","UNK_TYPE1","",0x1),
+    0x801ED8D8:("sHighestCameraDriftPriority","UNK_TYPE1","",0x1),
+    0x801ED8DC:("sAttentionPlayerRotY","UNK_TYPE1","",0x1),
     0x801ED8E0:("sActorHiliteMtx","Mtx","",0x40),
-    0x801ED920:("D_801ED920","Actor*","",0x1),
+    0x801ED920:("gCameraDriftActor","Actor*","",0x1),
     0x801ED930:("D_801ED930","FaultClient","",0x10),
     0x801ED940:("sActorOverlayTableFaultAddrConvClient","FaultAddrConvClient","",0xC),
     0x801ED950:("D_801ED950","char","[80]",0x50),
diff --git a/tools/namefixer.py b/tools/namefixer.py
index 7f49fe8222..c435790196 100755
--- a/tools/namefixer.py
+++ b/tools/namefixer.py
@@ -1298,8 +1298,8 @@ wordReplace = {
     "play->actorCtx.unk3": "play->actorCtx.lensActive",
     "play->actorCtx.unk4": "play->actorCtx.lensMaskSize",
     "play->actorCtx.targetContext": "play->actorCtx.attention",
-    "play->actorCtx.attention.unk0": "play->actorCtx.attention.fairyPos",
-    "play->actorCtx.attention.unk40": "play->actorCtx.attention.fairyMoveProgressFactor",
+    "play->actorCtx.attention.unk0": "play->actorCtx.attention.tatlHoverPos",
+    "play->actorCtx.attention.unk40": "play->actorCtx.attention.tatlMoveProgressFactor",
     "play->actorCtx.attention.unk44": "play->actorCtx.attention.lockOnRadius",
     "play->actorCtx.attention.unk48": "play->actorCtx.attention.lockOnAlpha",
     "play->actorCtx.attention.unk4B": "play->actorCtx.attention.rotation",
diff --git a/tools/sizes/code_functions.csv b/tools/sizes/code_functions.csv
index 1c59469284..9d2d5a7a12 100644
--- a/tools/sizes/code_functions.csv
+++ b/tools/sizes/code_functions.csv
@@ -185,7 +185,7 @@ asm/non_matchings/code/z_actor/func_800B4B50.s,func_800B4B50,0x800B4B50,0xE3
 asm/non_matchings/code/z_actor/Actor_GetProjectedPos.s,Actor_GetProjectedPos,0x800B4EDC,0x19
 asm/non_matchings/code/z_actor/Attention_SetReticlePos.s,Attention_SetReticlePos,0x800B4F40,0xE
 asm/non_matchings/code/z_actor/Attention_InitReticle.s,Attention_InitReticle,0x800B4F78,0x32
-asm/non_matchings/code/z_actor/Attention_SetFairyState.s,Attention_SetFairyState,0x800B5040,0x59
+asm/non_matchings/code/z_actor/Attention_SetTatlState.s,Attention_SetTatlState,0x800B5040,0x59
 asm/non_matchings/code/z_actor/Attention_Init.s,Attention_Init,0x800B51A4,0x19
 asm/non_matchings/code/z_actor/Attention_Draw.s,Attention_Draw,0x800B5208,0x183
 asm/non_matchings/code/z_actor/Attention_Update.s,Attention_Update,0x800B5814,0xE7
@@ -280,9 +280,9 @@ asm/non_matchings/code/z_actor/func_800B8118.s,func_800B8118,0x800B8118,0x32
 asm/non_matchings/code/z_actor/Actor_GetFocus.s,Actor_GetFocus,0x800B81E0,0xD
 asm/non_matchings/code/z_actor/Actor_GetWorld.s,Actor_GetWorld,0x800B8214,0xD
 asm/non_matchings/code/z_actor/Actor_GetWorldPosShapeRot.s,Actor_GetWorldPosShapeRot,0x800B8248,0x29
-asm/non_matchings/code/z_actor/Attention_GetAdjustedDistSq.s,Attention_GetAdjustedDistSq,0x800B82EC,0x34
-asm/non_matchings/code/z_actor/Attention_IsActorInRange.s,Attention_IsActorInRange,0x800B83BC,0xF
-asm/non_matchings/code/z_actor/Attention_OutsideLeashRange.s,Attention_OutsideLeashRange,0x800B83F8,0x36
+asm/non_matchings/code/z_actor/Attention_WeightedDistToPlayerSq.s,Attention_WeightedDistToPlayerSq,0x800B82EC,0x34
+asm/non_matchings/code/z_actor/Attention_ActorIsInRange.s,Attention_ActorIsInRange,0x800B83BC,0xF
+asm/non_matchings/code/z_actor/Attention_ShouldReleaseLockOn.s,Attention_ShouldReleaseLockOn,0x800B83F8,0x36
 asm/non_matchings/code/z_actor/Actor_TalkOfferAccepted.s,Actor_TalkOfferAccepted,0x800B84D0,0xC
 asm/non_matchings/code/z_actor/Actor_OfferTalkExchange.s,Actor_OfferTalkExchange,0x800B8500,0x38
 asm/non_matchings/code/z_actor/Actor_OfferTalkExchangeEquiCylinder.s,Actor_OfferTalkExchangeEquiCylinder,0x800B85E0,0xD
@@ -354,9 +354,9 @@ asm/non_matchings/code/z_actor/Actor_SpawnAsChild.s,Actor_SpawnAsChild,0x800BB0C
 asm/non_matchings/code/z_actor/Actor_SpawnTransitionActors.s,Actor_SpawnTransitionActors,0x800BB140,0x64
 asm/non_matchings/code/z_actor/Actor_SpawnEntry.s,Actor_SpawnEntry,0x800BB2D0,0x72
 asm/non_matchings/code/z_actor/Actor_Delete.s,Actor_Delete,0x800BB498,0x41
-asm/non_matchings/code/z_actor/Attention_InTargetableScreenRegion.s,Attention_InTargetableScreenRegion,0x800BB59C,0x1A
-asm/non_matchings/code/z_actor/Attention_FindTargetableActorForCategory.s,Attention_FindTargetableActorForCategory,0x800BB604,0xBA
-asm/non_matchings/code/z_actor/Attention_GetTargetActor.s,Attention_GetTargetActor,0x800BB8EC,0x67
+asm/non_matchings/code/z_actor/Attention_ActorOnScreen.s,Attention_ActorOnScreen,0x800BB59C,0x1A
+asm/non_matchings/code/z_actor/Attention_FindActorInCategory.s,Attention_FindActorInCategory,0x800BB604,0xBA
+asm/non_matchings/code/z_actor/Attention_FindActor.s,Attention_FindActor,0x800BB8EC,0x67
 asm/non_matchings/code/z_actor/Enemy_StartFinishingBlow.s,Enemy_StartFinishingBlow,0x800BBA88,0xE
 asm/non_matchings/code/z_actor/func_800BBAC0.s,func_800BBAC0,0x800BBAC0,0x2D
 asm/non_matchings/code/z_actor/func_800BBB74.s,func_800BBB74,0x800BBB74,0x2B
@@ -683,7 +683,7 @@ asm/non_matchings/code/z_camera/Camera_UpdateInterface.s,Camera_UpdateInterface,
 asm/non_matchings/code/z_camera/Camera_BgCheckCorner.s,Camera_BgCheckCorner,0x800CD3E4,0x1A
 asm/non_matchings/code/z_camera/func_800CD44C.s,func_800CD44C,0x800CD44C,0x7A
 asm/non_matchings/code/z_camera/Camera_CalcSlopeYAdj.s,Camera_CalcSlopeYAdj,0x800CD634,0x26
-asm/non_matchings/code/z_camera/func_800CD6CC.s,func_800CD6CC,0x800CD6CC,0xB
+asm/non_matchings/code/z_camera/Camera_GetAttentionActorRange.s,Camera_GetAttentionActorRange,0x800CD6CC,0xB
 asm/non_matchings/code/z_camera/Camera_CalcAtDefault.s,Camera_CalcAtDefault,0x800CD6F8,0x4F
 asm/non_matchings/code/z_camera/Camera_CalcAtForScreen.s,Camera_CalcAtForScreen,0x800CD834,0x78
 asm/non_matchings/code/z_camera/Camera_CalcAtForNormal1.s,Camera_CalcAtForNormal1,0x800CDA14,0x56