diff --git a/include/z64actor.h b/include/z64actor.h
index dd03d978ab..6f1b604e19 100644
--- a/include/z64actor.h
+++ b/include/z64actor.h
@@ -852,12 +852,12 @@ Actor* Actor_FindNearby(struct PlayState* play, Actor* inActor, s16 actorId, u8
 s32 func_800BE184(struct PlayState* play, Actor* actor, f32 xzDist, s16 arg3, s16 arg4, s16 arg5);
 u8 Actor_ApplyDamage(Actor* actor);
 void Actor_SetDropFlag(Actor* actor, ColliderElement* elem);
-void Actor_SetDropFlagJntSph(Actor* actor, ColliderJntSph* jntSphere);
+void Actor_SetDropFlagJntSph(Actor* actor, ColliderJntSph* jntSph);
 void func_800BE33C(Vec3f* arg0, Vec3f* arg1, Vec3s* dst, s32 arg3);
 void func_800BE3D0(Actor* actor, s16 angle, Vec3s* arg2);
 void func_800BE504(Actor* actor, ColliderCylinder* collider);
 void func_800BE568(Actor* actor, ColliderSphere* collider);
-void func_800BE5CC(Actor* actor, ColliderJntSph* collider, s32 colliderIndex);
+void func_800BE5CC(Actor* actor, ColliderJntSph* jntSph, s32 elemIndex);
 s32 Actor_IsSmallChest(struct EnBox* chest);
 void Actor_DrawDamageEffects(struct PlayState* play, Actor* actor, Vec3f bodyPartsPos[], s16 bodyPartsCount,
                              f32 effectScale, f32 frozenSteamScale, f32 effectAlpha, u8 type);
diff --git a/include/z64collision_check.h b/include/z64collision_check.h
index 11833d66d1..d031f3fb1b 100644
--- a/include/z64collision_check.h
+++ b/include/z64collision_check.h
@@ -93,6 +93,12 @@ typedef struct {
     /* 0x16 */ u8 ocElemFlags; // Information flags for OC collisions
 } ColliderElementInit; // size = 0x18
 
+/*
+ * JntSph - A collider made of sphere shaped elements. Each sphere can attach to a skeleton joint (limb).
+ */
+
+// collider structs
+
 typedef struct {
     /* 0x00 */ Sphere16 modelSphere; // model space sphere
     /* 0x08 */ Sphere16 worldSphere; // world space sphere
@@ -101,27 +107,29 @@ typedef struct {
 } ColliderJntSphElementDim; // size = 0x18
 
 typedef struct {
-    /* 0x0 */ u8 limb; // attached limb
-    /* 0x2 */ Sphere16 modelSphere; // model space sphere
-    /* 0xA */ s16 scale; // world space sphere = model * scale * 0.01
-} ColliderJntSphElementDimInit; // size = 0xC
-
-typedef struct {
-    /* 0x00 */ ColliderElement info;
+    /* 0x00 */ ColliderElement base;
     /* 0x28 */ ColliderJntSphElementDim dim;
 } ColliderJntSphElement; // size = 0x40
 
-typedef struct {
-    /* 0x00 */ ColliderElementInit info;
-    /* 0x18 */ ColliderJntSphElementDimInit dim;
-} ColliderJntSphElementInit; // size = 0x24
-
 typedef struct {
     /* 0x00 */ Collider base;
     /* 0x18 */ s32 count;
     /* 0x1C */ ColliderJntSphElement* elements;
 } ColliderJntSph; // size = 0x20
 
+// init data structs
+
+typedef struct {
+    /* 0x0 */ u8 limb; // attached limb
+    /* 0x2 */ Sphere16 modelSphere; // model space sphere
+    /* 0xA */ s16 scale; // world space sphere = model * scale * 0.01
+} ColliderJntSphElementDimInit; // size = 0xC
+
+typedef struct {
+    /* 0x00 */ ColliderElementInit base;
+    /* 0x18 */ ColliderJntSphElementDimInit dim;
+} ColliderJntSphElementInit; // size = 0x24
+
 typedef struct {
     /* 0x0 */ ColliderInit base;
     /* 0x8 */ s32 count;
@@ -492,19 +500,19 @@ void Collider_ResetOCElement(struct PlayState* play, ColliderElement* elem);
 s32 Collider_InitJntSphElementDim(struct PlayState* play, ColliderJntSphElementDim* dim);
 s32 Collider_DestroyJntSphElementDim(struct PlayState* play, ColliderJntSphElementDim* dim);
 s32 Collider_SetJntSphElementDim(struct PlayState* play, ColliderJntSphElementDim* dest, ColliderJntSphElementDimInit* src);
-s32 Collider_InitJntSphElement(struct PlayState* play, ColliderJntSphElement* element);
-s32 Collider_DestroyJntSphElement(struct PlayState* play, ColliderJntSphElement* element);
+s32 Collider_InitJntSphElement(struct PlayState* play, ColliderJntSphElement* jntSphElem);
+s32 Collider_DestroyJntSphElement(struct PlayState* play, ColliderJntSphElement* jntSphElem);
 s32 Collider_SetJntSphElement(struct PlayState* play, ColliderJntSphElement* dest, ColliderJntSphElementInit* src);
-s32 Collider_ResetJntSphElementAT(struct PlayState* play, ColliderJntSphElement* collider);
-s32 Collider_ResetJntSphElementAC(struct PlayState* play, ColliderJntSphElement* collider);
-s32 Collider_ResetJntSphElementOC(struct PlayState* play, ColliderJntSphElement* collider);
-s32 Collider_InitJntSph(struct PlayState* play, ColliderJntSph* collider);
-s32 Collider_FreeJntSph(struct PlayState* play, ColliderJntSph* collider);
-s32 Collider_DestroyJntSph(struct PlayState* play, ColliderJntSph* collider);
-s32 Collider_SetJntSphToActor(struct PlayState* play, ColliderJntSph* collider, ColliderJntSphInitToActor* src);
-s32 Collider_SetJntSphAllocType1(struct PlayState* play, ColliderJntSph* sphereGroup, struct Actor* actor, ColliderJntSphInitType1* src);
-s32 Collider_SetJntSph(struct PlayState* play, ColliderJntSph* sphereGroup, struct Actor* actor, ColliderJntSphInit* src, ColliderJntSphElement* elements);
-s32 Collider_InitAndSetJntSph(struct PlayState* play, ColliderJntSph* sphereGroup, struct Actor* actor, ColliderJntSphInit* src, ColliderJntSphElement* elements);
+s32 Collider_ResetJntSphElementAT(struct PlayState* play, ColliderJntSphElement* jntSphElem);
+s32 Collider_ResetJntSphElementAC(struct PlayState* play, ColliderJntSphElement* jntSphElem);
+s32 Collider_ResetJntSphElementOC(struct PlayState* play, ColliderJntSphElement* jntSphElem);
+s32 Collider_InitJntSph(struct PlayState* play, ColliderJntSph* jntSph);
+s32 Collider_FreeJntSph(struct PlayState* play, ColliderJntSph* jntSph);
+s32 Collider_DestroyJntSph(struct PlayState* play, ColliderJntSph* jntSph);
+s32 Collider_SetJntSphToActor(struct PlayState* play, ColliderJntSph* dest, ColliderJntSphInitToActor* src);
+s32 Collider_SetJntSphAllocType1(struct PlayState* play, ColliderJntSph* dest, struct Actor* actor, ColliderJntSphInitType1* src);
+s32 Collider_SetJntSph(struct PlayState* play, ColliderJntSph* dest, struct Actor* actor, ColliderJntSphInit* src, ColliderJntSphElement* jntSphElements);
+s32 Collider_InitAndSetJntSph(struct PlayState* play, ColliderJntSph* dest, struct Actor* actor, ColliderJntSphInit* src, ColliderJntSphElement* jntSphElements);
 s32 Collider_ResetJntSphAT(struct PlayState* play, Collider* col);
 s32 Collider_ResetJntSphAC(struct PlayState* play, Collider* col);
 s32 Collider_ResetJntSphOC(struct PlayState* play, Collider* col);
@@ -663,8 +671,8 @@ void Collider_SetCylinderPosition(ColliderCylinder* collider, Vec3s* pos);
 void Collider_SetQuadVertices(ColliderQuad* collider, Vec3f* a, Vec3f* b, Vec3f* c, Vec3f* d);
 void Collider_SetTrisVertices(ColliderTris* collider, s32 index, Vec3f* a, Vec3f* b, Vec3f* c);
 void Collider_SetTrisDim(struct PlayState* play, ColliderTris* collider, s32 index, ColliderTrisElementDimInit* init);
-void Collider_UpdateSpheres(s32 limb, ColliderJntSph* collider);
-void Collider_UpdateSpheresElement(ColliderJntSph* collider, s32 index, struct Actor* actor);
+void Collider_UpdateSpheres(s32 limb, ColliderJntSph* jntSph);
+void Collider_UpdateSpheresElement(ColliderJntSph* jntSph, s32 elemIndex, struct Actor* actor);
 void Collider_UpdateSphere(s32 limb, ColliderSphere* collider);
 void CollisionCheck_SpawnRedBlood(struct PlayState* play, Vec3f* v);
 void CollisionCheck_SpawnWaterDroplets(struct PlayState* play, Vec3f* v);
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 428404ae7e..ae7a0b1ac3 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -4723,17 +4723,17 @@ void Actor_SetDropFlag(Actor* actor, ColliderElement* elem) {
     }
 }
 
-void Actor_SetDropFlagJntSph(Actor* actor, ColliderJntSph* jntSphere) {
+void Actor_SetDropFlagJntSph(Actor* actor, ColliderJntSph* jntSph) {
     s32 i;
-    ColliderJntSphElement* jntElement;
+    ColliderJntSphElement* jntSphElem;
     ColliderElement* acHitElem;
     s32 flag;
 
     actor->dropFlag = DROPFLAG_NONE;
 
-    for (i = jntSphere->count - 1; i >= 0; i--) {
-        jntElement = &jntSphere->elements[i];
-        acHitElem = jntElement->info.acHitElem;
+    for (i = jntSph->count - 1; i >= 0; i--) {
+        jntSphElem = &jntSph->elements[i];
+        acHitElem = jntSphElem->base.acHitElem;
 
         if (acHitElem == NULL) {
             flag = DROPFLAG_NONE;
@@ -4806,12 +4806,11 @@ void func_800BE568(Actor* actor, ColliderSphere* collider) {
     }
 }
 
-void func_800BE5CC(Actor* actor, ColliderJntSph* collider, s32 colliderIndex) {
-    if (collider->elements[colliderIndex].info.acHitElem->toucher.dmgFlags &
-        (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20)) {
-        actor->world.rot.y = collider->base.ac->shape.rot.y;
+void func_800BE5CC(Actor* actor, ColliderJntSph* jntSph, s32 elemIndex) {
+    if (jntSph->elements[elemIndex].base.acHitElem->toucher.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20)) {
+        actor->world.rot.y = jntSph->base.ac->shape.rot.y;
     } else {
-        actor->world.rot.y = Actor_WorldYawTowardActor(collider->base.ac, actor);
+        actor->world.rot.y = Actor_WorldYawTowardActor(jntSph->base.ac, actor);
     }
 }
 
diff --git a/src/code/z_collision_check.c b/src/code/z_collision_check.c
index bf63e6912e..c77d9ea3b6 100644
--- a/src/code/z_collision_check.c
+++ b/src/code/z_collision_check.c
@@ -340,81 +340,81 @@ s32 Collider_SetJntSphElementDim(struct PlayState* play, ColliderJntSphElementDi
     return 1;
 }
 
-s32 Collider_InitJntSphElement(struct PlayState* play, ColliderJntSphElement* element) {
-    Collider_InitElement(play, &element->info);
-    Collider_InitJntSphElementDim(play, &element->dim);
+s32 Collider_InitJntSphElement(struct PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_InitElement(play, &jntSphElem->base);
+    Collider_InitJntSphElementDim(play, &jntSphElem->dim);
     return 1;
 }
 
-s32 Collider_DestroyJntSphElement(struct PlayState* play, ColliderJntSphElement* element) {
-    Collider_DestroyElement(play, &element->info);
-    Collider_DestroyJntSphElementDim(play, &element->dim);
+s32 Collider_DestroyJntSphElement(struct PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_DestroyElement(play, &jntSphElem->base);
+    Collider_DestroyJntSphElementDim(play, &jntSphElem->dim);
     return 1;
 }
 
 s32 Collider_SetJntSphElement(struct PlayState* play, ColliderJntSphElement* dest, ColliderJntSphElementInit* src) {
-    Collider_SetElement(play, &dest->info, &src->info);
+    Collider_SetElement(play, &dest->base, &src->base);
     Collider_SetJntSphElementDim(play, &dest->dim, &src->dim);
     return 1;
 }
 
-s32 Collider_ResetJntSphElementAT(struct PlayState* play, ColliderJntSphElement* collider) {
-    Collider_ResetATElement(play, &collider->info);
+s32 Collider_ResetJntSphElementAT(struct PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_ResetATElement(play, &jntSphElem->base);
     return 1;
 }
 
-s32 Collider_ResetJntSphElementAC(struct PlayState* play, ColliderJntSphElement* collider) {
-    Collider_ResetACElement(play, &collider->info);
+s32 Collider_ResetJntSphElementAC(struct PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_ResetACElement(play, &jntSphElem->base);
     return 1;
 }
 
-s32 Collider_ResetJntSphElementOC(struct PlayState* play, ColliderJntSphElement* collider) {
-    Collider_ResetOCElement(play, &collider->info);
+s32 Collider_ResetJntSphElementOC(struct PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_ResetOCElement(play, &jntSphElem->base);
     return 1;
 }
 
 /**
  * Initializes a ColliderJntSph to default values
  */
-s32 Collider_InitJntSph(struct PlayState* play, ColliderJntSph* collider) {
-    Collider_InitBase(play, &collider->base);
-    collider->count = 0;
-    collider->elements = NULL;
+s32 Collider_InitJntSph(struct PlayState* play, ColliderJntSph* jntSph) {
+    Collider_InitBase(play, &jntSph->base);
+    jntSph->count = 0;
+    jntSph->elements = NULL;
     return 1;
 }
 
 /**
  * Destroys a dynamically allocated ColliderJntSph
  */
-s32 Collider_FreeJntSph(struct PlayState* play, ColliderJntSph* collider) {
-    ColliderJntSphElement* element;
+s32 Collider_FreeJntSph(struct PlayState* play, ColliderJntSph* jntSph) {
+    ColliderJntSphElement* jntSphElem;
 
-    Collider_DestroyBase(play, &collider->base);
-    for (element = collider->elements; element < &collider->elements[collider->count]; element++) {
-        Collider_DestroyJntSphElement(play, element);
+    Collider_DestroyBase(play, &jntSph->base);
+    for (jntSphElem = jntSph->elements; jntSphElem < &jntSph->elements[jntSph->count]; jntSphElem++) {
+        Collider_DestroyJntSphElement(play, jntSphElem);
     }
 
-    collider->count = 0;
-    if (collider->elements != NULL) {
-        ZeldaArena_Free(collider->elements);
+    jntSph->count = 0;
+    if (jntSph->elements != NULL) {
+        ZeldaArena_Free(jntSph->elements);
     }
-    collider->elements = NULL;
+    jntSph->elements = NULL;
     return 1;
 }
 
 /**
  * Destroys a preallocated ColliderJntSph
  */
-s32 Collider_DestroyJntSph(struct PlayState* play, ColliderJntSph* collider) {
-    ColliderJntSphElement* element;
+s32 Collider_DestroyJntSph(struct PlayState* play, ColliderJntSph* jntSph) {
+    ColliderJntSphElement* jntSphElem;
 
-    Collider_DestroyBase(play, &collider->base);
+    Collider_DestroyBase(play, &jntSph->base);
 
-    for (element = collider->elements; element < &collider->elements[collider->count]; element++) {
-        Collider_DestroyJntSphElement(play, element);
+    for (jntSphElem = jntSph->elements; jntSphElem < &jntSph->elements[jntSph->count]; jntSphElem++) {
+        Collider_DestroyJntSphElement(play, jntSphElem);
     }
-    collider->count = 0;
-    collider->elements = NULL;
+    jntSph->count = 0;
+    jntSph->elements = NULL;
     return 1;
 }
 
@@ -422,20 +422,20 @@ s32 Collider_DestroyJntSph(struct PlayState* play, ColliderJntSph* collider) {
  * Sets up the ColliderJntSph using the values in src, sets it to the actor specified in src, and dynamically allocates
  * the element array. Uses default OC2_TYPE_1 and COLTYPE_HIT0.
  */
-s32 Collider_SetJntSphToActor(struct PlayState* play, ColliderJntSph* collider, ColliderJntSphInitToActor* src) {
+s32 Collider_SetJntSphToActor(struct PlayState* play, ColliderJntSph* dest, ColliderJntSphInitToActor* src) {
     ColliderJntSphElement* destElem;
     ColliderJntSphElementInit* srcElem;
 
-    Collider_SetBaseToActor(play, &collider->base, &src->base);
-    collider->count = src->count;
-    collider->elements = ZeldaArena_Malloc(src->count * sizeof(ColliderJntSphElement));
+    Collider_SetBaseToActor(play, &dest->base, &src->base);
+    dest->count = src->count;
+    dest->elements = ZeldaArena_Malloc(src->count * sizeof(ColliderJntSphElement));
 
-    if (collider->elements == NULL) {
-        collider->count = 0;
+    if (dest->elements == NULL) {
+        dest->count = 0;
         return 0;
     }
 
-    for (destElem = collider->elements, srcElem = src->elements; destElem < &collider->elements[collider->count];
+    for (destElem = dest->elements, srcElem = src->elements; destElem < &dest->elements[dest->count];
          destElem++, srcElem++) {
         Collider_InitJntSphElement(play, destElem);
         Collider_SetJntSphElement(play, destElem, srcElem);
@@ -447,22 +447,22 @@ s32 Collider_SetJntSphToActor(struct PlayState* play, ColliderJntSph* collider,
  * Sets up the ColliderJntSph using the values in src and dynamically allocates the element array. Uses default
  * OC2_TYPE_1.
  */
-s32 Collider_SetJntSphAllocType1(struct PlayState* play, ColliderJntSph* sphereGroup, Actor* actor,
+s32 Collider_SetJntSphAllocType1(struct PlayState* play, ColliderJntSph* dest, Actor* actor,
                                  ColliderJntSphInitType1* src) {
     ColliderJntSphElement* destElem;
     ColliderJntSphElementInit* srcElem;
 
-    Collider_SetBaseType1(play, &sphereGroup->base, actor, &src->base);
-    sphereGroup->count = src->count;
-    sphereGroup->elements = ZeldaArena_Malloc(src->count * sizeof(ColliderJntSphElement));
+    Collider_SetBaseType1(play, &dest->base, actor, &src->base);
+    dest->count = src->count;
+    dest->elements = ZeldaArena_Malloc(src->count * sizeof(ColliderJntSphElement));
 
-    if (sphereGroup->elements == NULL) {
-        sphereGroup->count = 0;
+    if (dest->elements == NULL) {
+        dest->count = 0;
         return 0;
     }
 
-    for (destElem = sphereGroup->elements, srcElem = src->elements;
-         destElem < &sphereGroup->elements[sphereGroup->count]; destElem++, srcElem++) {
+    for (destElem = dest->elements, srcElem = src->elements; destElem < &dest->elements[dest->count];
+         destElem++, srcElem++) {
         Collider_InitJntSphElement(play, destElem);
         Collider_SetJntSphElement(play, destElem, srcElem);
     }
@@ -472,17 +472,17 @@ s32 Collider_SetJntSphAllocType1(struct PlayState* play, ColliderJntSph* sphereG
 /**
  * Sets up the ColliderJntSph using the values in src, placing the element array in elements.
  */
-s32 Collider_SetJntSph(struct PlayState* play, ColliderJntSph* sphereGroup, Actor* actor, ColliderJntSphInit* src,
-                       ColliderJntSphElement* elements) {
+s32 Collider_SetJntSph(struct PlayState* play, ColliderJntSph* dest, Actor* actor, ColliderJntSphInit* src,
+                       ColliderJntSphElement* jntSphElements) {
     ColliderJntSphElement* destElem;
     ColliderJntSphElementInit* srcElem;
 
-    Collider_SetBase(play, &sphereGroup->base, actor, &src->base);
-    sphereGroup->count = src->count;
-    sphereGroup->elements = elements;
+    Collider_SetBase(play, &dest->base, actor, &src->base);
+    dest->count = src->count;
+    dest->elements = jntSphElements;
 
-    for (destElem = sphereGroup->elements, srcElem = src->elements;
-         destElem < &sphereGroup->elements[sphereGroup->count]; destElem++, srcElem++) {
+    for (destElem = dest->elements, srcElem = src->elements; destElem < &dest->elements[dest->count];
+         destElem++, srcElem++) {
         Collider_InitJntSphElement(play, destElem);
         Collider_SetJntSphElement(play, destElem, srcElem);
     }
@@ -493,10 +493,10 @@ s32 Collider_SetJntSph(struct PlayState* play, ColliderJntSph* sphereGroup, Acto
 /**
  * Fully initializes a ColliderJntSph using the values in `src`, placing the element array in elements.
  */
-s32 Collider_InitAndSetJntSph(struct PlayState* play, ColliderJntSph* sphereGroup, Actor* actor,
-                              ColliderJntSphInit* src, ColliderJntSphElement* elements) {
-    Collider_InitJntSph(play, sphereGroup);
-    Collider_SetJntSph(play, sphereGroup, actor, src, elements);
+s32 Collider_InitAndSetJntSph(struct PlayState* play, ColliderJntSph* dest, Actor* actor, ColliderJntSphInit* src,
+                              ColliderJntSphElement* jntSphElements) {
+    Collider_InitJntSph(play, dest);
+    Collider_SetJntSph(play, dest, actor, src, jntSphElements);
     return 0;
 }
 
@@ -504,13 +504,13 @@ s32 Collider_InitAndSetJntSph(struct PlayState* play, ColliderJntSph* sphereGrou
  * Resets the collider's AT collision flags.
  */
 s32 Collider_ResetJntSphAT(struct PlayState* play, Collider* col) {
-    ColliderJntSphElement* element;
+    ColliderJntSphElement* jntSphElem;
     ColliderJntSph* jntSph = (ColliderJntSph*)col;
 
     Collider_ResetATBase(play, &jntSph->base);
 
-    for (element = jntSph->elements; element < &jntSph->elements[jntSph->count]; element++) {
-        Collider_ResetJntSphElementAT(play, element);
+    for (jntSphElem = jntSph->elements; jntSphElem < &jntSph->elements[jntSph->count]; jntSphElem++) {
+        Collider_ResetJntSphElementAT(play, jntSphElem);
     }
     return 1;
 }
@@ -519,13 +519,13 @@ s32 Collider_ResetJntSphAT(struct PlayState* play, Collider* col) {
  * Resets the collider's AC collision flags.
  */
 s32 Collider_ResetJntSphAC(struct PlayState* play, Collider* col) {
-    ColliderJntSphElement* element;
+    ColliderJntSphElement* jntSphElem;
     ColliderJntSph* jntSph = (ColliderJntSph*)col;
 
     Collider_ResetACBase(play, &jntSph->base);
 
-    for (element = jntSph->elements; element < &jntSph->elements[jntSph->count]; element++) {
-        Collider_ResetJntSphElementAC(play, element);
+    for (jntSphElem = jntSph->elements; jntSphElem < &jntSph->elements[jntSph->count]; jntSphElem++) {
+        Collider_ResetJntSphElementAC(play, jntSphElem);
     }
     return 1;
 }
@@ -534,13 +534,13 @@ s32 Collider_ResetJntSphAC(struct PlayState* play, Collider* col) {
  * Resets the collider's OC collision flags.
  */
 s32 Collider_ResetJntSphOC(struct PlayState* play, Collider* col) {
-    ColliderJntSphElement* element;
+    ColliderJntSphElement* jntSphElem;
     ColliderJntSph* jntSph = (ColliderJntSph*)col;
 
     Collider_ResetOCBase(play, &jntSph->base);
 
-    for (element = jntSph->elements; element < &jntSph->elements[jntSph->count]; element++) {
-        Collider_ResetJntSphElementOC(play, element);
+    for (jntSphElem = jntSph->elements; jntSphElem < &jntSph->elements[jntSph->count]; jntSphElem++) {
+        Collider_ResetJntSphElementOC(play, jntSphElem);
     }
     return 1;
 }
@@ -1783,49 +1783,51 @@ TriNorm D_801EF638;
  */
 void CollisionCheck_AC_JntSphVsJntSph(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                       Collider* acCol) {
-    ColliderJntSph* at = (ColliderJntSph*)atCol;
-    ColliderJntSphElement* atElem;
-    ColliderJntSph* ac = (ColliderJntSph*)acCol;
-    ColliderJntSphElement* acElem;
+    ColliderJntSph* atJntSph = (ColliderJntSph*)atCol;
+    ColliderJntSphElement* atJntSphElem;
+    ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
+    ColliderJntSphElement* acJntSphElem;
     f32 overlapSize;
     f32 centerDist;
 
-    if ((at->count > 0) && (at->elements != NULL) && (ac->count > 0) && (ac->elements != NULL)) {
-        for (atElem = at->elements; atElem < &at->elements[at->count]; atElem++) {
-            if (CollisionCheck_SkipTouch(&atElem->info)) {
+    if ((atJntSph->count > 0) && (atJntSph->elements != NULL) && (acJntSph->count > 0) &&
+        (acJntSph->elements != NULL)) {
+        for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
+            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
                 continue;
             }
 
-            for (acElem = ac->elements; acElem < &ac->elements[ac->count]; acElem++) {
-                if (CollisionCheck_SkipBump(&acElem->info)) {
+            for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count];
+                 acJntSphElem++) {
+                if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
                     continue;
                 }
-                if (CollisionCheck_NoSharedFlags(&atElem->info, &acElem->info)) {
+                if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acJntSphElem->base)) {
                     continue;
                 }
 
-                if (Math3D_SphVsSphOverlapCenterDist(&atElem->dim.worldSphere, &acElem->dim.worldSphere, &overlapSize,
-                                                     &centerDist)) {
+                if (Math3D_SphVsSphOverlapCenterDist(&atJntSphElem->dim.worldSphere, &acJntSphElem->dim.worldSphere,
+                                                     &overlapSize, &centerDist)) {
                     f32 acToHit;
                     Vec3f hitPos;
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    Math_Vec3s_ToVec3f(&atPos, &atElem->dim.worldSphere.center);
-                    Math_Vec3s_ToVec3f(&acPos, &acElem->dim.worldSphere.center);
+                    Math_Vec3s_ToVec3f(&atPos, &atJntSphElem->dim.worldSphere.center);
+                    Math_Vec3s_ToVec3f(&acPos, &acJntSphElem->dim.worldSphere.center);
 
                     if (!IS_ZERO(centerDist)) {
-                        acToHit = acElem->dim.worldSphere.radius / centerDist;
+                        acToHit = acJntSphElem->dim.worldSphere.radius / centerDist;
                         hitPos.x = ((atPos.x - acPos.x) * acToHit) + acPos.x;
                         hitPos.y = ((atPos.y - acPos.y) * acToHit) + acPos.y;
                         hitPos.z = ((atPos.z - acPos.z) * acToHit) + acPos.z;
                     } else {
                         Math_Vec3f_Copy(&hitPos, &atPos);
                     }
-                    CollisionCheck_SetATvsAC(play, &at->base, &atElem->info, &atPos, &ac->base, &acElem->info, &acPos,
-                                             &hitPos);
+                    CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &acJntSph->base,
+                                             &acJntSphElem->base, &acPos, &hitPos);
 
-                    if (!(ac->base.ocFlags2 & OC2_FIRST_ONLY)) {
+                    if (!(acJntSph->base.ocFlags2 & OC2_FIRST_ONLY)) {
                         return;
                     }
                 }
@@ -1839,30 +1841,30 @@ void CollisionCheck_AC_JntSphVsJntSph(struct PlayState* play, CollisionCheckCont
  */
 void CollisionCheck_AC_JntSphVsCyl(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                    Collider* acCol) {
-    ColliderJntSph* at = (ColliderJntSph*)atCol;
-    ColliderJntSphElement* atElem;
+    ColliderJntSph* atJntSph = (ColliderJntSph*)atCol;
+    ColliderJntSphElement* atJntSphElem;
     ColliderCylinder* ac = (ColliderCylinder*)acCol;
     f32 overlapSize;
     f32 centerDist;
 
-    if ((at->count > 0) && (at->elements != NULL) && (ac->dim.radius > 0) && (ac->dim.height > 0)) {
+    if ((atJntSph->count > 0) && (atJntSph->elements != NULL) && (ac->dim.radius > 0) && (ac->dim.height > 0)) {
         if (CollisionCheck_SkipBump(&ac->info)) {
             return;
         }
-        for (atElem = at->elements; atElem < &at->elements[at->count]; atElem++) {
-            if (CollisionCheck_SkipTouch(&atElem->info)) {
+        for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
+            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&atElem->info, &ac->info)) {
+            if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &ac->info)) {
                 continue;
             }
-            if (Math3D_SphVsCylOverlapCenterDist(&atElem->dim.worldSphere, &ac->dim, &overlapSize, &centerDist)) {
+            if (Math3D_SphVsCylOverlapCenterDist(&atJntSphElem->dim.worldSphere, &ac->dim, &overlapSize, &centerDist)) {
                 Vec3f hitPos;
                 Vec3f atPos;
                 Vec3f acPos;
                 f32 acToHit;
 
-                Math_Vec3s_ToVec3f(&atPos, &atElem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&atPos, &atJntSphElem->dim.worldSphere.center);
                 Math_Vec3s_ToVec3f(&acPos, &ac->dim.pos);
                 if (!IS_ZERO(centerDist)) {
                     acToHit = ac->dim.radius / centerDist;
@@ -1876,7 +1878,8 @@ void CollisionCheck_AC_JntSphVsCyl(struct PlayState* play, CollisionCheckContext
                 } else {
                     Math_Vec3f_Copy(&hitPos, &atPos);
                 }
-                CollisionCheck_SetATvsAC(play, &at->base, &atElem->info, &atPos, &ac->base, &ac->info, &acPos, &hitPos);
+                CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &ac->base, &ac->info,
+                                         &acPos, &hitPos);
                 return;
             }
         }
@@ -1888,32 +1891,32 @@ void CollisionCheck_AC_JntSphVsCyl(struct PlayState* play, CollisionCheckContext
  */
 void CollisionCheck_AC_JntSphVsTris(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                     Collider* acCol) {
-    ColliderJntSph* at = (ColliderJntSph*)atCol;
-    ColliderJntSphElement* atElem;
+    ColliderJntSph* atJntSph = (ColliderJntSph*)atCol;
+    ColliderJntSphElement* atJntSphElem;
     ColliderTris* ac = (ColliderTris*)acCol;
     ColliderTrisElement* acElem;
     Vec3f hitPos;
 
-    if ((at->count > 0) && (at->elements != NULL) && (ac->count > 0) && (ac->elements != NULL)) {
-        for (atElem = at->elements; atElem < &at->elements[at->count]; atElem++) {
-            if (CollisionCheck_SkipTouch(&atElem->info)) {
+    if ((atJntSph->count > 0) && (atJntSph->elements != NULL) && (ac->count > 0) && (ac->elements != NULL)) {
+        for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
+            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
                 continue;
             }
             for (acElem = ac->elements; acElem < &ac->elements[ac->count]; acElem++) {
                 if (CollisionCheck_SkipBump(&acElem->info)) {
                     continue;
                 }
-                if (CollisionCheck_NoSharedFlags(&atElem->info, &acElem->info)) {
+                if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acElem->info)) {
                     continue;
                 }
-                if (Math3D_TriVsSphIntersect(&atElem->dim.worldSphere, &acElem->dim, &hitPos)) {
+                if (Math3D_TriVsSphIntersect(&atJntSphElem->dim.worldSphere, &acElem->dim, &hitPos)) {
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    Math_Vec3s_ToVec3f(&atPos, &atElem->dim.worldSphere.center);
+                    Math_Vec3s_ToVec3f(&atPos, &atJntSphElem->dim.worldSphere.center);
                     CollisionCheck_TrisAvgPoint(acElem, &acPos);
-                    CollisionCheck_SetATvsAC(play, &at->base, &atElem->info, &atPos, &ac->base, &acElem->info, &acPos,
-                                             &hitPos);
+                    CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &ac->base,
+                                             &acElem->info, &acPos, &hitPos);
                     return;
                 }
             }
@@ -1926,34 +1929,34 @@ void CollisionCheck_AC_JntSphVsTris(struct PlayState* play, CollisionCheckContex
  */
 void CollisionCheck_AC_JntSphVsQuad(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                     Collider* acCol) {
-    ColliderJntSph* at = (ColliderJntSph*)atCol;
+    ColliderJntSph* atJntSph = (ColliderJntSph*)atCol;
     ColliderQuad* ac = (ColliderQuad*)acCol;
     Vec3f hitPos;
-    ColliderJntSphElement* sphElem;
+    ColliderJntSphElement* atJntSphElem;
 
-    if ((at->count > 0) && (at->elements != NULL)) {
+    if ((atJntSph->count > 0) && (atJntSph->elements != NULL)) {
         if (CollisionCheck_SkipBump(&ac->info)) {
             return;
         }
         Math3D_TriNorm(&D_801EF590, &ac->dim.quad[2], &ac->dim.quad[3], &ac->dim.quad[1]);
         Math3D_TriNorm(&D_801EF5C8, &ac->dim.quad[1], &ac->dim.quad[0], &ac->dim.quad[2]);
 
-        for (sphElem = at->elements; sphElem < &at->elements[at->count]; sphElem++) {
-            if (CollisionCheck_SkipTouch(&sphElem->info)) {
+        for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
+            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&sphElem->info, &ac->info)) {
+            if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &ac->info)) {
                 continue;
             }
-            if (Math3D_TriVsSphIntersect(&sphElem->dim.worldSphere, &D_801EF590, &hitPos) ||
-                Math3D_TriVsSphIntersect(&sphElem->dim.worldSphere, &D_801EF5C8, &hitPos)) {
+            if (Math3D_TriVsSphIntersect(&atJntSphElem->dim.worldSphere, &D_801EF590, &hitPos) ||
+                Math3D_TriVsSphIntersect(&atJntSphElem->dim.worldSphere, &D_801EF5C8, &hitPos)) {
                 Vec3f atPos;
                 Vec3f acPos;
 
-                Math_Vec3s_ToVec3f(&atPos, &sphElem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&atPos, &atJntSphElem->dim.worldSphere.center);
                 CollisionCheck_QuadAvgPoint(ac, &acPos);
-                CollisionCheck_SetATvsAC(play, &at->base, &sphElem->info, &atPos, &ac->base, &ac->info, &acPos,
-                                         &hitPos);
+                CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &ac->base, &ac->info,
+                                         &acPos, &hitPos);
                 return;
             }
         }
@@ -1965,31 +1968,31 @@ void CollisionCheck_AC_JntSphVsQuad(struct PlayState* play, CollisionCheckContex
  */
 void CollisionCheck_AC_JntSphVsSphere(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                       Collider* acCol) {
-    ColliderJntSph* at = (ColliderJntSph*)atCol;
+    ColliderJntSph* atJntSph = (ColliderJntSph*)atCol;
     ColliderSphere* ac = (ColliderSphere*)acCol;
-    ColliderJntSphElement* sphElem;
+    ColliderJntSphElement* atJntSphElem;
     f32 overlapSize;
     f32 centerDist;
 
-    if ((at->count > 0) && (at->elements != NULL)) {
+    if ((atJntSph->count > 0) && (atJntSph->elements != NULL)) {
         if (CollisionCheck_SkipBump(&ac->info)) {
             return;
         }
-        for (sphElem = at->elements; sphElem < &at->elements[at->count]; sphElem++) {
-            if (CollisionCheck_SkipTouch(&sphElem->info)) {
+        for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
+            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&sphElem->info, &ac->info)) {
+            if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &ac->info)) {
                 continue;
             }
-            if (Math3D_SphVsSphOverlapCenterDist(&sphElem->dim.worldSphere, &ac->dim.worldSphere, &overlapSize,
+            if (Math3D_SphVsSphOverlapCenterDist(&atJntSphElem->dim.worldSphere, &ac->dim.worldSphere, &overlapSize,
                                                  &centerDist)) {
                 f32 acToHit;
                 Vec3f hitPos;
                 Vec3f atPos;
                 Vec3f acPos;
 
-                Math_Vec3s_ToVec3f(&atPos, &sphElem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&atPos, &atJntSphElem->dim.worldSphere.center);
                 Math_Vec3s_ToVec3f(&acPos, &ac->dim.worldSphere.center);
                 if (!IS_ZERO(centerDist)) {
                     acToHit = ac->dim.worldSphere.radius / centerDist;
@@ -1999,8 +2002,8 @@ void CollisionCheck_AC_JntSphVsSphere(struct PlayState* play, CollisionCheckCont
                 } else {
                     Math_Vec3f_Copy(&hitPos, &atPos);
                 }
-                CollisionCheck_SetATvsAC(play, &at->base, &sphElem->info, &atPos, &ac->base, &ac->info, &acPos,
-                                         &hitPos);
+                CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &ac->base, &ac->info,
+                                         &acPos, &hitPos);
             }
         }
     }
@@ -2012,32 +2015,32 @@ void CollisionCheck_AC_JntSphVsSphere(struct PlayState* play, CollisionCheckCont
 void CollisionCheck_AC_CylVsJntSph(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                    Collider* acCol) {
     ColliderCylinder* at = (ColliderCylinder*)atCol;
-    ColliderJntSph* ac = (ColliderJntSph*)acCol;
+    ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
     f32 overlapSize;
     f32 centerDist;
-    ColliderJntSphElement* sphElem;
+    ColliderJntSphElement* acJntSphElem;
 
-    if ((ac->count > 0) && (ac->elements != NULL) && (at->dim.radius > 0) && (at->dim.height > 0)) {
+    if ((acJntSph->count > 0) && (acJntSph->elements != NULL) && (at->dim.radius > 0) && (at->dim.height > 0)) {
         if (CollisionCheck_SkipTouch(&at->info)) {
             return;
         }
-        for (sphElem = ac->elements; sphElem < &ac->elements[ac->count]; sphElem++) {
-            if (CollisionCheck_SkipBump(&sphElem->info)) {
+        for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count]; acJntSphElem++) {
+            if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&at->info, &sphElem->info)) {
+            if (CollisionCheck_NoSharedFlags(&at->info, &acJntSphElem->base)) {
                 continue;
             }
-            if (Math3D_SphVsCylOverlapCenterDist(&sphElem->dim.worldSphere, &at->dim, &overlapSize, &centerDist)) {
+            if (Math3D_SphVsCylOverlapCenterDist(&acJntSphElem->dim.worldSphere, &at->dim, &overlapSize, &centerDist)) {
                 Vec3f hitPos;
                 Vec3f atPos;
                 Vec3f acPos;
                 f32 acToHit;
 
                 Math_Vec3s_ToVec3f(&atPos, &at->dim.pos);
-                Math_Vec3s_ToVec3f(&acPos, &sphElem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&acPos, &acJntSphElem->dim.worldSphere.center);
                 if (!IS_ZERO(centerDist)) {
-                    acToHit = sphElem->dim.worldSphere.radius / centerDist;
+                    acToHit = acJntSphElem->dim.worldSphere.radius / centerDist;
                     if (acToHit <= 1.0f) {
                         hitPos.x = ((atPos.x - acPos.x) * acToHit) + acPos.x;
                         hitPos.y = ((atPos.y - acPos.y) * acToHit) + acPos.y;
@@ -2048,9 +2051,9 @@ void CollisionCheck_AC_CylVsJntSph(struct PlayState* play, CollisionCheckContext
                 } else {
                     Math_Vec3f_Copy(&hitPos, &atPos);
                 }
-                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &ac->base, &sphElem->info, &acPos,
-                                         &hitPos);
-                if (!(ac->base.ocFlags2 & OC2_FIRST_ONLY)) {
+                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &acJntSph->base, &acJntSphElem->base,
+                                         &acPos, &hitPos);
+                if (!(acJntSph->base.ocFlags2 & OC2_FIRST_ONLY)) {
                     break;
                 }
             }
@@ -2239,33 +2242,33 @@ void CollisionCheck_AC_CylVsSphere(struct PlayState* play, CollisionCheckContext
 void CollisionCheck_AC_TrisVsJntSph(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                     Collider* acCol) {
     ColliderTris* at = (ColliderTris*)atCol;
-    ColliderJntSphElement* acElem;
-    ColliderJntSph* ac = (ColliderJntSph*)acCol;
+    ColliderJntSphElement* acJntSphElem;
+    ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
     ColliderTrisElement* atElem;
     Vec3f hitPos;
 
-    if ((ac->count > 0) && (ac->elements != NULL) && (at->count > 0) && (at->elements != NULL)) {
-        for (acElem = ac->elements; acElem < &ac->elements[ac->count]; acElem++) {
-            if (CollisionCheck_SkipBump(&acElem->info)) {
+    if ((acJntSph->count > 0) && (acJntSph->elements != NULL) && (at->count > 0) && (at->elements != NULL)) {
+        for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count]; acJntSphElem++) {
+            if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
                 continue;
             }
             for (atElem = at->elements; atElem < &at->elements[at->count]; atElem++) {
                 if (CollisionCheck_SkipTouch(&atElem->info)) {
                     continue;
                 }
-                if (CollisionCheck_NoSharedFlags(&atElem->info, &acElem->info)) {
+                if (CollisionCheck_NoSharedFlags(&atElem->info, &acJntSphElem->base)) {
                     continue;
                 }
-                if (Math3D_TriVsSphIntersect(&acElem->dim.worldSphere, &atElem->dim, &hitPos)) {
+                if (Math3D_TriVsSphIntersect(&acJntSphElem->dim.worldSphere, &atElem->dim, &hitPos)) {
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    Math_Vec3s_ToVec3f(&acPos, &acElem->dim.worldSphere.center);
+                    Math_Vec3s_ToVec3f(&acPos, &acJntSphElem->dim.worldSphere.center);
                     CollisionCheck_TrisAvgPoint(atElem, &atPos);
-                    CollisionCheck_SetATvsAC(play, &at->base, &atElem->info, &atPos, &ac->base, &acElem->info, &acPos,
-                                             &hitPos);
+                    CollisionCheck_SetATvsAC(play, &at->base, &atElem->info, &atPos, &acJntSph->base,
+                                             &acJntSphElem->base, &acPos, &hitPos);
 
-                    if (!(ac->base.ocFlags2 & OC2_FIRST_ONLY)) {
+                    if (!(acJntSph->base.ocFlags2 & OC2_FIRST_ONLY)) {
                         return;
                     }
                 }
@@ -2422,38 +2425,39 @@ void CollisionCheck_AC_TrisVsSphere(struct PlayState* play, CollisionCheckContex
  */
 void CollisionCheck_AC_QuadVsJntSph(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                     Collider* acCol) {
-    ColliderJntSphElement* acElem;
+    ColliderJntSphElement* acJntSphElem;
     Vec3f hitPos;
     ColliderQuad* at = (ColliderQuad*)atCol;
-    ColliderJntSph* ac = (ColliderJntSph*)acCol;
+    ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
 
-    if ((ac->count > 0) && (ac->elements != NULL)) {
+    if ((acJntSph->count > 0) && (acJntSph->elements != NULL)) {
         if (CollisionCheck_SkipTouch(&at->info)) {
             return;
         }
         Math3D_TriNorm(&D_801EDEC8, &at->dim.quad[2], &at->dim.quad[3], &at->dim.quad[1]);
         Math3D_TriNorm(&D_801EDF00, &at->dim.quad[2], &at->dim.quad[1], &at->dim.quad[0]);
 
-        for (acElem = ac->elements; acElem < &ac->elements[ac->count]; acElem++) {
-            if (CollisionCheck_SkipBump(&acElem->info)) {
+        for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count]; acJntSphElem++) {
+            if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&at->info, &acElem->info)) {
+            if (CollisionCheck_NoSharedFlags(&at->info, &acJntSphElem->base)) {
                 continue;
             }
-            if (Math3D_TriVsSphIntersect(&acElem->dim.worldSphere, &D_801EDEC8, &hitPos) ||
-                Math3D_TriVsSphIntersect(&acElem->dim.worldSphere, &D_801EDF00, &hitPos)) {
+            if (Math3D_TriVsSphIntersect(&acJntSphElem->dim.worldSphere, &D_801EDEC8, &hitPos) ||
+                Math3D_TriVsSphIntersect(&acJntSphElem->dim.worldSphere, &D_801EDF00, &hitPos)) {
                 Vec3f atPos;
                 Vec3f acPos;
 
                 if (!Collider_QuadSetNearestAC(play, at, &hitPos)) {
                     continue;
                 }
-                Math_Vec3s_ToVec3f(&acPos, &acElem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&acPos, &acJntSphElem->dim.worldSphere.center);
                 CollisionCheck_QuadAvgPoint(at, &atPos);
-                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &ac->base, &acElem->info, &acPos, &hitPos);
+                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &acJntSph->base, &acJntSphElem->base,
+                                         &acPos, &hitPos);
 
-                if (!(ac->base.ocFlags2 & OC2_FIRST_ONLY)) {
+                if (!(acJntSph->base.ocFlags2 & OC2_FIRST_ONLY)) {
                     break;
                 }
             }
@@ -2628,25 +2632,25 @@ void CollisionCheck_AC_QuadVsSphere(struct PlayState* play, CollisionCheckContex
 void CollisionCheck_AC_SphereVsJntSph(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
                                       Collider* acCol) {
     ColliderSphere* at = (ColliderSphere*)atCol;
-    ColliderJntSph* ac = (ColliderJntSph*)acCol;
-    ColliderJntSphElement* acElem;
+    ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
+    ColliderJntSphElement* acJntSphElem;
     f32 overlapSize;
     f32 centerDist;
 
-    if ((ac->count > 0) && (ac->elements != NULL)) {
+    if ((acJntSph->count > 0) && (acJntSph->elements != NULL)) {
         if (CollisionCheck_SkipTouch(&at->info)) {
             return;
         }
 
-        for (acElem = ac->elements; acElem < &ac->elements[ac->count]; acElem++) {
-            if (CollisionCheck_SkipBump(&acElem->info)) {
+        for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count]; acJntSphElem++) {
+            if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&at->info, &acElem->info)) {
+            if (CollisionCheck_NoSharedFlags(&at->info, &acJntSphElem->base)) {
                 continue;
             }
 
-            if (Math3D_SphVsSphOverlapCenterDist(&at->dim.worldSphere, &acElem->dim.worldSphere, &overlapSize,
+            if (Math3D_SphVsSphOverlapCenterDist(&at->dim.worldSphere, &acJntSphElem->dim.worldSphere, &overlapSize,
                                                  &centerDist)) {
                 f32 acToHit;
                 Vec3f hitPos;
@@ -2654,16 +2658,17 @@ void CollisionCheck_AC_SphereVsJntSph(struct PlayState* play, CollisionCheckCont
                 Vec3f acPos;
 
                 Math_Vec3s_ToVec3f(&atPos, &at->dim.worldSphere.center);
-                Math_Vec3s_ToVec3f(&acPos, &acElem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&acPos, &acJntSphElem->dim.worldSphere.center);
                 if (!IS_ZERO(centerDist)) {
-                    acToHit = acElem->dim.worldSphere.radius / centerDist;
+                    acToHit = acJntSphElem->dim.worldSphere.radius / centerDist;
                     hitPos.x = (atPos.x - acPos.x) * acToHit + acPos.x;
                     hitPos.y = (atPos.y - acPos.y) * acToHit + acPos.y;
                     hitPos.z = (atPos.z - acPos.z) * acToHit + acPos.z;
                 } else {
                     Math_Vec3f_Copy(&hitPos, &atPos);
                 }
-                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &ac->base, &acElem->info, &acPos, &hitPos);
+                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &acJntSph->base, &acJntSphElem->base,
+                                         &acPos, &hitPos);
             }
         }
     }
@@ -2824,17 +2829,17 @@ void CollisionCheck_AC_SphereVsSphere(struct PlayState* play, CollisionCheckCont
  */
 void CollisionCheck_SetJntSphHitFX(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
     ColliderJntSph* jntSph = (ColliderJntSph*)col;
-    ColliderJntSphElement* element;
+    ColliderJntSphElement* jntSphElem;
 
-    for (element = jntSph->elements; element < &jntSph->elements[jntSph->count]; element++) {
-        if ((element->info.bumperFlags & BUMP_DRAW_HITMARK) && (element->info.acHitElem != NULL) &&
-            !(element->info.acHitElem->toucherFlags & TOUCH_DREW_HITMARK)) {
+    for (jntSphElem = jntSph->elements; jntSphElem < &jntSph->elements[jntSph->count]; jntSphElem++) {
+        if ((jntSphElem->base.bumperFlags & BUMP_DRAW_HITMARK) && (jntSphElem->base.acHitElem != NULL) &&
+            !(jntSphElem->base.acHitElem->toucherFlags & TOUCH_DREW_HITMARK)) {
             Vec3f hitPos;
 
-            Math_Vec3s_ToVec3f(&hitPos, &element->info.bumper.hitPos);
-            CollisionCheck_HitEffects(play, element->info.acHit, element->info.acHitElem, &jntSph->base, &element->info,
-                                      &hitPos);
-            element->info.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
+            Math_Vec3s_ToVec3f(&hitPos, &jntSphElem->base.bumper.hitPos);
+            CollisionCheck_HitEffects(play, jntSphElem->base.acHit, jntSphElem->base.acHitElem, &jntSph->base,
+                                      &jntSphElem->base, &hitPos);
+            jntSphElem->base.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
             return;
         }
     }
@@ -3149,31 +3154,35 @@ void CollisionCheck_SetOCvsOC(struct PlayState* play, Collider* leftCol, Collide
  */
 void CollisionCheck_OC_JntSphVsJntSph(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* leftCol,
                                       Collider* rightCol) {
-    ColliderJntSph* left = (ColliderJntSph*)leftCol;
-    ColliderJntSph* right = (ColliderJntSph*)rightCol;
-    ColliderJntSphElement* leftElem;
-    ColliderJntSphElement* rightElem;
+    ColliderJntSph* leftJntSph = (ColliderJntSph*)leftCol;
+    ColliderJntSph* rightJntSph = (ColliderJntSph*)rightCol;
+    ColliderJntSphElement* leftJntSphElem;
+    ColliderJntSphElement* rightJntSphElem;
     f32 overlapSize;
 
-    if ((left->count > 0) && (left->elements != NULL) && (right->count > 0) && (right->elements != NULL) &&
-        (left->base.ocFlags1 & OCELEM_ON) && (right->base.ocFlags1 & OCELEM_ON)) {
+    if ((leftJntSph->count > 0) && (leftJntSph->elements != NULL) && (rightJntSph->count > 0) &&
+        (rightJntSph->elements != NULL) && (leftJntSph->base.ocFlags1 & OCELEM_ON) &&
+        (rightJntSph->base.ocFlags1 & OCELEM_ON)) {
 
-        for (leftElem = left->elements; leftElem < &left->elements[left->count]; leftElem++) {
-            if (!(leftElem->info.ocElemFlags & OCELEM_ON)) {
+        for (leftJntSphElem = leftJntSph->elements; leftJntSphElem < &leftJntSph->elements[leftJntSph->count];
+             leftJntSphElem++) {
+            if (!(leftJntSphElem->base.ocElemFlags & OCELEM_ON)) {
                 continue;
             }
-            for (rightElem = right->elements; rightElem < &right->elements[right->count]; rightElem++) {
-                if (!(rightElem->info.ocElemFlags & OCELEM_ON)) {
+            for (rightJntSphElem = rightJntSph->elements; rightJntSphElem < &rightJntSph->elements[rightJntSph->count];
+                 rightJntSphElem++) {
+                if (!(rightJntSphElem->base.ocElemFlags & OCELEM_ON)) {
                     continue;
                 }
-                if (Math3D_SphVsSphOverlap(&leftElem->dim.worldSphere, &rightElem->dim.worldSphere, &overlapSize)) {
+                if (Math3D_SphVsSphOverlap(&leftJntSphElem->dim.worldSphere, &rightJntSphElem->dim.worldSphere,
+                                           &overlapSize)) {
                     Vec3f leftPos;
                     Vec3f rightPos;
 
-                    Math_Vec3s_ToVec3f(&leftPos, &leftElem->dim.worldSphere.center);
-                    Math_Vec3s_ToVec3f(&rightPos, &rightElem->dim.worldSphere.center);
-                    CollisionCheck_SetOCvsOC(play, &left->base, &leftElem->info, &leftPos, &right->base,
-                                             &rightElem->info, &rightPos, overlapSize);
+                    Math_Vec3s_ToVec3f(&leftPos, &leftJntSphElem->dim.worldSphere.center);
+                    Math_Vec3s_ToVec3f(&rightPos, &rightJntSphElem->dim.worldSphere.center);
+                    CollisionCheck_SetOCvsOC(play, &leftJntSph->base, &leftJntSphElem->base, &leftPos,
+                                             &rightJntSph->base, &rightJntSphElem->base, &rightPos, overlapSize);
                 }
             }
         }
@@ -3185,26 +3194,27 @@ void CollisionCheck_OC_JntSphVsJntSph(struct PlayState* play, CollisionCheckCont
  */
 void CollisionCheck_OC_JntSphVsCyl(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* leftCol,
                                    Collider* rightCol) {
-    ColliderJntSph* left = (ColliderJntSph*)leftCol;
+    ColliderJntSph* leftJntSph = (ColliderJntSph*)leftCol;
     ColliderCylinder* right = (ColliderCylinder*)rightCol;
-    ColliderJntSphElement* leftElem;
+    ColliderJntSphElement* leftJntSphElem;
     f32 overlapSize;
 
-    if ((left->count > 0) && (left->elements != NULL) && (left->base.ocFlags1 & OCELEM_ON) &&
+    if ((leftJntSph->count > 0) && (leftJntSph->elements != NULL) && (leftJntSph->base.ocFlags1 & OCELEM_ON) &&
         (right->base.ocFlags1 & OCELEM_ON) && (right->info.ocElemFlags & OCELEM_ON)) {
 
-        for (leftElem = left->elements; leftElem < &left->elements[left->count]; leftElem++) {
-            if (!(leftElem->info.ocElemFlags & OCELEM_ON)) {
+        for (leftJntSphElem = leftJntSph->elements; leftJntSphElem < &leftJntSph->elements[leftJntSph->count];
+             leftJntSphElem++) {
+            if (!(leftJntSphElem->base.ocElemFlags & OCELEM_ON)) {
                 continue;
             }
-            if (Math3D_SphVsCylOverlap(&leftElem->dim.worldSphere, &right->dim, &overlapSize)) {
+            if (Math3D_SphVsCylOverlap(&leftJntSphElem->dim.worldSphere, &right->dim, &overlapSize)) {
                 Vec3f leftPos;
                 Vec3f rightPos;
 
-                Math_Vec3s_ToVec3f(&leftPos, &leftElem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&leftPos, &leftJntSphElem->dim.worldSphere.center);
                 Math_Vec3s_ToVec3f(&rightPos, &right->dim.pos);
-                CollisionCheck_SetOCvsOC(play, &left->base, &leftElem->info, &leftPos, &right->base, &right->info,
-                                         &rightPos, overlapSize);
+                CollisionCheck_SetOCvsOC(play, &leftJntSph->base, &leftJntSphElem->base, &leftPos, &right->base,
+                                         &right->info, &rightPos, overlapSize);
             }
         }
     }
@@ -3215,26 +3225,27 @@ void CollisionCheck_OC_JntSphVsCyl(struct PlayState* play, CollisionCheckContext
  */
 void CollisionCheck_OC_JntSphVsSphere(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* leftCol,
                                       Collider* rightCol) {
-    ColliderJntSph* left = (ColliderJntSph*)leftCol;
+    ColliderJntSph* leftJntSph = (ColliderJntSph*)leftCol;
     ColliderSphere* right = (ColliderSphere*)rightCol;
-    ColliderJntSphElement* leftElem;
+    ColliderJntSphElement* leftJntSphElem;
     f32 overlapSize;
 
-    if ((left->count > 0) && (left->elements != NULL) && (left->base.ocFlags1 & OCELEM_ON) &&
+    if ((leftJntSph->count > 0) && (leftJntSph->elements != NULL) && (leftJntSph->base.ocFlags1 & OCELEM_ON) &&
         (right->base.ocFlags1 & OCELEM_ON) && (right->info.ocElemFlags & OCELEM_ON)) {
 
-        for (leftElem = left->elements; leftElem < &left->elements[left->count]; leftElem++) {
-            if (!(leftElem->info.ocElemFlags & OCELEM_ON)) {
+        for (leftJntSphElem = leftJntSph->elements; leftJntSphElem < &leftJntSph->elements[leftJntSph->count];
+             leftJntSphElem++) {
+            if (!(leftJntSphElem->base.ocElemFlags & OCELEM_ON)) {
                 continue;
             }
-            if (Math3D_SphVsSphOverlap(&leftElem->dim.worldSphere, &right->dim.worldSphere, &overlapSize)) {
+            if (Math3D_SphVsSphOverlap(&leftJntSphElem->dim.worldSphere, &right->dim.worldSphere, &overlapSize)) {
                 Vec3f leftPos;
                 Vec3f rightPos;
 
-                Math_Vec3s_ToVec3f(&leftPos, &leftElem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&leftPos, &leftJntSphElem->dim.worldSphere.center);
                 Math_Vec3s_ToVec3f(&rightPos, &right->dim.worldSphere.center);
-                CollisionCheck_SetOCvsOC(play, &left->base, &leftElem->info, &leftPos, &right->base, &right->info,
-                                         &rightPos, overlapSize);
+                CollisionCheck_SetOCvsOC(play, &leftJntSph->base, &leftJntSphElem->base, &leftPos, &right->base,
+                                         &right->info, &rightPos, overlapSize);
             }
         }
     }
@@ -3556,7 +3567,7 @@ void CollisionCheck_ApplyDamageJntSph(struct PlayState* play, CollisionCheckCont
 
     if ((jntSph->count > 0) && (jntSph->elements != NULL)) {
         for (i = 0; i < jntSph->count; i++) {
-            CollisionCheck_ApplyDamage(play, colChkCtx, &jntSph->base, &jntSph->elements[i].info);
+            CollisionCheck_ApplyDamage(play, colChkCtx, &jntSph->base, &jntSph->elements[i].base);
         }
     }
 }
@@ -3639,15 +3650,15 @@ s32 CollisionCheck_LineOC_JntSph(struct PlayState* play, CollisionCheckContext*
     s32 i;
 
     for (i = 0; i < jntSph->count; i++) {
-        ColliderJntSphElement* element = &jntSph->elements[i];
+        ColliderJntSphElement* jntSphElem = &jntSph->elements[i];
 
-        if (!(element->info.ocElemFlags & OCELEM_ON)) {
+        if (!(jntSphElem->base.ocElemFlags & OCELEM_ON)) {
             continue;
         }
 
         D_801EDEB0.a = *a;
         D_801EDEB0.b = *b;
-        if (Math3D_LineVsSph(&element->dim.worldSphere, &D_801EDEB0)) {
+        if (Math3D_LineVsSph(&jntSphElem->dim.worldSphere, &D_801EDEB0)) {
             return true;
         }
     }
@@ -3819,22 +3830,22 @@ void Collider_SetTrisDim(struct PlayState* play, ColliderTris* collider, s32 ind
 /**
  * Updates the world spheres for all of the collider's JntSph elements attached to the specified limb
  */
-void Collider_UpdateSpheres(s32 limb, ColliderJntSph* collider) {
+void Collider_UpdateSpheres(s32 limb, ColliderJntSph* jntSph) {
     static Vec3f D_801EE1C0;
     static Vec3f D_801EE1D0;
     s32 i;
 
-    for (i = 0; i < collider->count; i++) {
-        if (limb == collider->elements[i].dim.limb) {
-            D_801EE1C0.x = collider->elements[i].dim.modelSphere.center.x;
-            D_801EE1C0.y = collider->elements[i].dim.modelSphere.center.y;
-            D_801EE1C0.z = collider->elements[i].dim.modelSphere.center.z;
+    for (i = 0; i < jntSph->count; i++) {
+        if (limb == jntSph->elements[i].dim.limb) {
+            D_801EE1C0.x = jntSph->elements[i].dim.modelSphere.center.x;
+            D_801EE1C0.y = jntSph->elements[i].dim.modelSphere.center.y;
+            D_801EE1C0.z = jntSph->elements[i].dim.modelSphere.center.z;
             Matrix_MultVec3f(&D_801EE1C0, &D_801EE1D0);
-            collider->elements[i].dim.worldSphere.center.x = D_801EE1D0.x;
-            collider->elements[i].dim.worldSphere.center.y = D_801EE1D0.y;
-            collider->elements[i].dim.worldSphere.center.z = D_801EE1D0.z;
-            collider->elements[i].dim.worldSphere.radius =
-                collider->elements[i].dim.modelSphere.radius * collider->elements[i].dim.scale;
+            jntSph->elements[i].dim.worldSphere.center.x = D_801EE1D0.x;
+            jntSph->elements[i].dim.worldSphere.center.y = D_801EE1D0.y;
+            jntSph->elements[i].dim.worldSphere.center.z = D_801EE1D0.z;
+            jntSph->elements[i].dim.worldSphere.radius =
+                jntSph->elements[i].dim.modelSphere.radius * jntSph->elements[i].dim.scale;
         }
     }
 }
@@ -3842,16 +3853,16 @@ void Collider_UpdateSpheres(s32 limb, ColliderJntSph* collider) {
 /**
  * Updates the world spheres for the specified ColliderJntSph element
  */
-void Collider_UpdateSpheresElement(ColliderJntSph* collider, s32 index, Actor* actor) {
-    if (index < collider->count) {
-        collider->elements[index].dim.worldSphere.center.x =
-            collider->elements[index].dim.modelSphere.center.x + actor->world.pos.x;
-        collider->elements[index].dim.worldSphere.center.y =
-            collider->elements[index].dim.modelSphere.center.y + actor->world.pos.y;
-        collider->elements[index].dim.worldSphere.center.z =
-            collider->elements[index].dim.modelSphere.center.z + actor->world.pos.z;
-        collider->elements[index].dim.worldSphere.radius =
-            collider->elements[index].dim.modelSphere.radius * collider->elements[index].dim.scale;
+void Collider_UpdateSpheresElement(ColliderJntSph* jntSph, s32 elemIndex, Actor* actor) {
+    if (elemIndex < jntSph->count) {
+        jntSph->elements[elemIndex].dim.worldSphere.center.x =
+            jntSph->elements[elemIndex].dim.modelSphere.center.x + actor->world.pos.x;
+        jntSph->elements[elemIndex].dim.worldSphere.center.y =
+            jntSph->elements[elemIndex].dim.modelSphere.center.y + actor->world.pos.y;
+        jntSph->elements[elemIndex].dim.worldSphere.center.z =
+            jntSph->elements[elemIndex].dim.modelSphere.center.z + actor->world.pos.z;
+        jntSph->elements[elemIndex].dim.worldSphere.radius =
+            jntSph->elements[elemIndex].dim.modelSphere.radius * jntSph->elements[elemIndex].dim.scale;
     }
 }
 
diff --git a/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c b/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c
index da6a3ff23c..7e69cfe2de 100644
--- a/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c
+++ b/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c
@@ -103,7 +103,7 @@ s32 BgKin2Fence_CheckHitMask(BgKin2Fence* this) {
     s32 i;
 
     for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++) {
-        if (this->collider.elements[i].info.bumperFlags & BUMP_HIT) {
+        if (this->collider.elements[i].base.bumperFlags & BUMP_HIT) {
             return i;
         }
     }
diff --git a/src/overlays/actors/ovl_Boss_01/z_boss_01.c b/src/overlays/actors/ovl_Boss_01/z_boss_01.c
index 3c8e19b292..be23d13da6 100644
--- a/src/overlays/actors/ovl_Boss_01/z_boss_01.c
+++ b/src/overlays/actors/ovl_Boss_01/z_boss_01.c
@@ -1951,10 +1951,10 @@ void Boss01_UpdateDamage(Boss01* this, PlayState* play) {
     u8 damage;
     s32 i;
 
-    if (this->shieldCollider.elements[ODOLWA_SHIELD_COLLIDER_SHIELD].info.bumperFlags & BUMP_HIT) {
+    if (this->shieldCollider.elements[ODOLWA_SHIELD_COLLIDER_SHIELD].base.bumperFlags & BUMP_HIT) {
         this->bodyInvincibilityTimer = 5;
         if (this->damagedTimer == 0) {
-            ColliderElement* acHitElem = this->shieldCollider.elements[ODOLWA_SHIELD_COLLIDER_SHIELD].info.acHitElem;
+            ColliderElement* acHitElem = this->shieldCollider.elements[ODOLWA_SHIELD_COLLIDER_SHIELD].base.acHitElem;
 
             if (acHitElem->toucher.dmgFlags == DMG_SWORD_BEAM) {
                 Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->actor.focus.pos.x, this->actor.focus.pos.y,
@@ -1965,24 +1965,24 @@ void Boss01_UpdateDamage(Boss01* this, PlayState* play) {
         }
     } else if (this->damagedTimer == 0) {
         for (i = 0; i < ODOLWA_SWORD_COLLIDER_MAX; i++) {
-            if (this->swordCollider.elements[i].info.toucherFlags & TOUCH_HIT) {
-                this->swordCollider.elements[i].info.toucherFlags &= ~TOUCH_HIT;
+            if (this->swordCollider.elements[i].base.toucherFlags & TOUCH_HIT) {
+                this->swordCollider.elements[i].base.toucherFlags &= ~TOUCH_HIT;
                 player->pushedYaw = this->actor.yawTowardsPlayer;
                 player->pushedSpeed = 15.0f;
             }
         }
 
         for (i = 0; i < ODOLWA_KICK_AND_SHIELD_BASH_COLLIDER_MAX; i++) {
-            if (this->kickAndShieldBashCollider.elements[i].info.toucherFlags & TOUCH_HIT) {
-                this->kickAndShieldBashCollider.elements[i].info.toucherFlags &= ~TOUCH_HIT;
+            if (this->kickAndShieldBashCollider.elements[i].base.toucherFlags & TOUCH_HIT) {
+                this->kickAndShieldBashCollider.elements[i].base.toucherFlags &= ~TOUCH_HIT;
                 player->pushedYaw = this->actor.yawTowardsPlayer;
                 player->pushedSpeed = 20.0f;
             }
         }
 
         for (i = 0; i < ODOLWA_COLLIDER_BODYPART_MAX; i++) {
-            if (this->bodyCollider.elements[i].info.bumperFlags & BUMP_HIT) {
-                this->bodyCollider.elements[i].info.bumperFlags &= ~BUMP_HIT;
+            if (this->bodyCollider.elements[i].base.bumperFlags & BUMP_HIT) {
+                this->bodyCollider.elements[i].base.bumperFlags &= ~BUMP_HIT;
 
                 switch (this->actor.colChkInfo.damageEffect) {
                     case ODOLWA_DMGEFF_FREEZE:
@@ -2408,7 +2408,7 @@ void Boss01_Update(Actor* thisx, PlayState* play2) {
         } else {
             this->bodyInvincibilityTimer--;
             for (i = 0; i < ODOLWA_COLLIDER_BODYPART_MAX; i++) {
-                this->bodyCollider.elements[i].info.bumperFlags &= ~BUMP_HIT;
+                this->bodyCollider.elements[i].base.bumperFlags &= ~BUMP_HIT;
             }
         }
 
@@ -2428,7 +2428,7 @@ void Boss01_Update(Actor* thisx, PlayState* play2) {
     } else {
         this->disableCollisionTimer--;
         for (i = 0; i < ODOLWA_COLLIDER_BODYPART_MAX; i++) {
-            this->bodyCollider.elements[i].info.bumperFlags &= ~BUMP_HIT;
+            this->bodyCollider.elements[i].base.bumperFlags &= ~BUMP_HIT;
         }
     }
 
diff --git a/src/overlays/actors/ovl_Boss_02/z_boss_02.c b/src/overlays/actors/ovl_Boss_02/z_boss_02.c
index 919c3ed7ae..34dafe5f08 100644
--- a/src/overlays/actors/ovl_Boss_02/z_boss_02.c
+++ b/src/overlays/actors/ovl_Boss_02/z_boss_02.c
@@ -1107,8 +1107,8 @@ void func_809DBFB4(Boss02* this, PlayState* play) {
         }
 
         for (i = temp; i < ARRAY_COUNT(this->colliderSphere2Elements); i++) {
-            if (this->colliderSphere2.elements[i].info.bumperFlags & BUMP_HIT) {
-                this->colliderSphere2.elements[i].info.bumperFlags &= ~BUMP_HIT;
+            if (this->colliderSphere2.elements[i].base.bumperFlags & BUMP_HIT) {
+                this->colliderSphere2.elements[i].base.bumperFlags &= ~BUMP_HIT;
                 this->unk_0154 = 15;
                 this->unk_0156 = 15;
 
diff --git a/src/overlays/actors/ovl_Boss_03/z_boss_03.c b/src/overlays/actors/ovl_Boss_03/z_boss_03.c
index a159531610..0ed565b098 100644
--- a/src/overlays/actors/ovl_Boss_03/z_boss_03.c
+++ b/src/overlays/actors/ovl_Boss_03/z_boss_03.c
@@ -220,14 +220,14 @@ void Boss03_SpawnEffectBubble(PlayState* play, Vec3f* pos) {
 /* End of SpawnEffect section */
 
 void Boss03_UpdateSphereElement(s32 index, ColliderJntSph* collider, Vec3f* sphereCenter) {
-    ColliderJntSphElement* sphElement;
+    ColliderJntSphElement* jntSphElem;
 
     collider->elements[index].dim.worldSphere.center.x = sphereCenter->x;
     collider->elements[index].dim.worldSphere.center.y = sphereCenter->y;
     collider->elements[index].dim.worldSphere.center.z = sphereCenter->z;
 
-    sphElement = &collider->elements[index];
-    sphElement->dim.worldSphere.radius = sphElement->dim.scale * sphElement->dim.modelSphere.radius;
+    jntSphElem = &collider->elements[index];
+    jntSphElem->dim.worldSphere.radius = jntSphElem->dim.scale * jntSphElem->dim.modelSphere.radius;
 }
 
 /* Start of RNG section */
@@ -1843,16 +1843,16 @@ void Boss03_UpdateCollision(Boss03* this, PlayState* play) {
 
     if (this->waterHeight < player->actor.world.pos.y) {
         for (i = 0; i < ARRAY_COUNT(sHeadJntSphElementsInit); i++) {
-            if (this->headCollider.elements[i].info.toucherFlags & TOUCH_HIT) {
-                this->headCollider.elements[i].info.toucherFlags &= ~TOUCH_HIT;
+            if (this->headCollider.elements[i].base.toucherFlags & TOUCH_HIT) {
+                this->headCollider.elements[i].base.toucherFlags &= ~TOUCH_HIT;
                 player->pushedYaw = this->actor.shape.rot.y;
                 player->pushedSpeed = 20.0f;
             }
         }
 
         for (i = 0; i < ARRAY_COUNT(sBodyJntSphElementsInit); i++) {
-            if (this->bodyCollider.elements[i].info.toucherFlags & TOUCH_HIT) {
-                this->bodyCollider.elements[i].info.toucherFlags &= ~TOUCH_HIT;
+            if (this->bodyCollider.elements[i].base.toucherFlags & TOUCH_HIT) {
+                this->bodyCollider.elements[i].base.toucherFlags &= ~TOUCH_HIT;
                 player->pushedYaw = this->actor.shape.rot.y;
                 player->pushedSpeed = 20.0f;
             }
@@ -1862,16 +1862,16 @@ void Boss03_UpdateCollision(Boss03* this, PlayState* play) {
     if (this->unk_25C == 0) {
         if ((this->actionFunc == stunnedActionFunc) && sp4B) {
             for (i = 0; i < ARRAY_COUNT(sBodyJntSphElementsInit); i++) {
-                if (this->bodyCollider.elements[i].info.bumperFlags & BUMP_HIT) {
-                    acHitElem = this->bodyCollider.elements[i].info.acHitElem;
-                    this->bodyCollider.elements[i].info.bumperFlags &= ~BUMP_HIT;
+                if (this->bodyCollider.elements[i].base.bumperFlags & BUMP_HIT) {
+                    acHitElem = this->bodyCollider.elements[i].base.acHitElem;
+                    this->bodyCollider.elements[i].base.bumperFlags &= ~BUMP_HIT;
                     this->unk_25C = 15;
                     this->unk_25E = 15;
 
                     // (DMG_SWORD_BEAM | DMG_SPIN_ATTACK | DMG_ZORA_PUNCH | DMG_ZORA_BARRIER | DMG_DEKU_LAUNCH |
                     // DMG_DEKU_SPIN | DMG_GORON_SPIKES | DMG_SWORD | DMG_GORON_PUNCH | DMG_DEKU_STICK)
                     phi_v0 = (acHitElem->toucher.dmgFlags & 0x038AC302)
-                                 ? this->bodyCollider.elements[i].info.acHitElem->toucher.damage
+                                 ? this->bodyCollider.elements[i].base.acHitElem->toucher.damage
                                  : 0;
 
                     phi_v1 = phi_v0;
@@ -1895,9 +1895,9 @@ void Boss03_UpdateCollision(Boss03* this, PlayState* play) {
         }
 
         for (i = 0; i < ARRAY_COUNT(sHeadJntSphElementsInit); i++) {
-            if (this->headCollider.elements[i].info.bumperFlags & BUMP_HIT) {
-                acHitElem = this->headCollider.elements[i].info.acHitElem;
-                this->headCollider.elements[i].info.bumperFlags &= ~BUMP_HIT;
+            if (this->headCollider.elements[i].base.bumperFlags & BUMP_HIT) {
+                acHitElem = this->headCollider.elements[i].base.acHitElem;
+                this->headCollider.elements[i].base.bumperFlags &= ~BUMP_HIT;
                 this->unk_25C = 15;
 
                 if (this->actionFunc != stunnedActionFunc) {
@@ -1920,7 +1920,7 @@ void Boss03_UpdateCollision(Boss03* this, PlayState* play) {
                     // (DMG_SWORD_BEAM | DMG_SPIN_ATTACK | DMG_ZORA_PUNCH | DMG_ZORA_BARRIER | DMG_DEKU_LAUNCH |
                     // DMG_DEKU_SPIN | DMG_GORON_SPIKES | DMG_SWORD | DMG_GORON_PUNCH | DMG_DEKU_STICK)
                     phi_v0 = (acHitElem->toucher.dmgFlags & 0x038AC302)
-                                 ? (this->headCollider.elements[i].info.acHitElem->toucher.damage)
+                                 ? (this->headCollider.elements[i].base.acHitElem->toucher.damage)
                                  : 0;
 
                     phi_v1 = phi_v0;
diff --git a/src/overlays/actors/ovl_Boss_04/z_boss_04.c b/src/overlays/actors/ovl_Boss_04/z_boss_04.c
index 96390c0ce3..0da7f2399a 100644
--- a/src/overlays/actors/ovl_Boss_04/z_boss_04.c
+++ b/src/overlays/actors/ovl_Boss_04/z_boss_04.c
@@ -565,11 +565,10 @@ void func_809ED2A0(Boss04* this, PlayState* play) {
 }
 
 void func_809ED45C(Boss04* this, PlayState* play) {
-    ColliderJntSphElement* temp_v0;
     u8 damage;
 
-    if ((this->unk_1FE == 0) && (this->collider1.elements[0].info.bumperFlags & BUMP_HIT)) {
-        this->collider1.elements[0].info.bumperFlags &= ~BUMP_HIT;
+    if ((this->unk_1FE == 0) && (this->collider1.elements[0].base.bumperFlags & BUMP_HIT)) {
+        this->collider1.elements[0].base.bumperFlags &= ~BUMP_HIT;
         Actor_PlaySfx(&this->actor, NA_SE_EN_ME_DAMAGE);
         damage = this->actor.colChkInfo.damage;
         this->actor.colChkInfo.health -= damage;
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 d0832160b1..e757d6f03c 100644
--- a/src/overlays/actors/ovl_Boss_05/z_boss_05.c
+++ b/src/overlays/actors/ovl_Boss_05/z_boss_05.c
@@ -468,7 +468,7 @@ s32 Boss05_LilyPadWithHead_UpdateDamage(Boss05* this, PlayState* play) {
         s32 i = 0;
 
         while (true) {
-            if (this->lilyPadCollider.elements[i].info.bumperFlags & BUMP_HIT) {
+            if (this->lilyPadCollider.elements[i].base.bumperFlags & BUMP_HIT) {
                 switch (this->dyna.actor.colChkInfo.damageEffect) {
                     case BIO_BABA_DMGEFF_FIRE:
                         return BIO_BABA_HEAD_HIT_REACTION_DEATCH + BIO_BABA_DRAW_DMGEFF_STATE_FIRE_INIT;
@@ -486,7 +486,7 @@ s32 Boss05_LilyPadWithHead_UpdateDamage(Boss05* this, PlayState* play) {
 
             i++;
             if (i == BIO_BABA_LILY_PAD_COLLIDER_MAX) {
-                if (this->headCollider.elements[BIO_BABA_HEAD_COLLIDER_HEAD].info.bumperFlags & BUMP_HIT) {
+                if (this->headCollider.elements[BIO_BABA_HEAD_COLLIDER_HEAD].base.bumperFlags & BUMP_HIT) {
                     u8 damage = this->dyna.actor.colChkInfo.damage;
 
                     this->dyna.actor.colChkInfo.health -= damage;
@@ -950,9 +950,9 @@ void Boss05_WalkingHead_UpdateDamage(Boss05* this, PlayState* play) {
     ColliderElement* acHitElem;
 
     if ((this->damagedTimer == 0) &&
-        (this->headCollider.elements[BIO_BABA_HEAD_COLLIDER_HEAD].info.bumperFlags & BUMP_HIT)) {
-        this->headCollider.elements[BIO_BABA_HEAD_COLLIDER_HEAD].info.bumperFlags &= ~BUMP_HIT;
-        acHitElem = this->headCollider.elements[BIO_BABA_HEAD_COLLIDER_HEAD].info.acHitElem;
+        (this->headCollider.elements[BIO_BABA_HEAD_COLLIDER_HEAD].base.bumperFlags & BUMP_HIT)) {
+        this->headCollider.elements[BIO_BABA_HEAD_COLLIDER_HEAD].base.bumperFlags &= ~BUMP_HIT;
+        acHitElem = this->headCollider.elements[BIO_BABA_HEAD_COLLIDER_HEAD].base.acHitElem;
         if (acHitElem->toucher.dmgFlags & 0x300000) { // (DMG_NORMAL_SHIELD | DMG_LIGHT_RAY)
             this->knockbackMagnitude = -12.0f;
             this->knockbackAngle = this->dyna.actor.yawTowardsPlayer;
diff --git a/src/overlays/actors/ovl_Boss_Hakugin/z_boss_hakugin.c b/src/overlays/actors/ovl_Boss_Hakugin/z_boss_hakugin.c
index 8906591250..7cbde63a78 100644
--- a/src/overlays/actors/ovl_Boss_Hakugin/z_boss_hakugin.c
+++ b/src/overlays/actors/ovl_Boss_Hakugin/z_boss_hakugin.c
@@ -1498,9 +1498,9 @@ void BossHakugin_UpdateDrawDmgEffect(BossHakugin* this, PlayState* play, s32 col
         this->drawDmgEffAlpha = 3.0f;
         this->drawDmgEffScale = 2.5f;
         Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG,
-                    this->bodyCollider.elements[colliderIndex].info.bumper.hitPos.x,
-                    this->bodyCollider.elements[colliderIndex].info.bumper.hitPos.y,
-                    this->bodyCollider.elements[colliderIndex].info.bumper.hitPos.z, 0, 0, 0,
+                    this->bodyCollider.elements[colliderIndex].base.bumper.hitPos.x,
+                    this->bodyCollider.elements[colliderIndex].base.bumper.hitPos.y,
+                    this->bodyCollider.elements[colliderIndex].base.bumper.hitPos.z, 0, 0, 0,
                     CLEAR_TAG_PARAMS(CLEAR_TAG_LARGE_LIGHT_RAYS));
     } else if (this->actor.colChkInfo.damageEffect == GOHT_DMGEFF_FREEZE) {
         this->drawDmgEffType = ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX;
@@ -1512,9 +1512,9 @@ void BossHakugin_UpdateDrawDmgEffect(BossHakugin* this, PlayState* play, s32 col
         this->drawDmgEffScale = 2.5f;
         this->drawDmgEffAlpha = 3.0f;
         Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG,
-                    this->bodyCollider.elements[colliderIndex].info.bumper.hitPos.x,
-                    this->bodyCollider.elements[colliderIndex].info.bumper.hitPos.y,
-                    this->bodyCollider.elements[colliderIndex].info.bumper.hitPos.z, 0, 0, 3,
+                    this->bodyCollider.elements[colliderIndex].base.bumper.hitPos.x,
+                    this->bodyCollider.elements[colliderIndex].base.bumper.hitPos.y,
+                    this->bodyCollider.elements[colliderIndex].base.bumper.hitPos.z, 0, 0, 3,
                     CLEAR_TAG_PARAMS(CLEAR_TAG_LARGE_LIGHT_RAYS));
     }
 }
@@ -2621,7 +2621,7 @@ void BossHakugin_CheckForBodyColliderHit(BossHakugin* this, PlayState* play) {
     if ((this->bodyCollider.base.atFlags & AT_HIT) &&
         ((this->actionFunc == BossHakugin_Charge) || !(player->stateFlags3 & PLAYER_STATE3_80000))) {
         if ((this->actionFunc == BossHakugin_Charge) &&
-            (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_HEAD].info.toucherFlags & TOUCH_HIT) &&
+            (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_HEAD].base.toucherFlags & TOUCH_HIT) &&
             !(this->bodyCollider.base.atFlags & AT_BOUNCED) && play->grabPlayer(play, player)) {
             BossHakugin_SetupThrow(this, play);
         } else if (player->stateFlags3 & PLAYER_STATE3_1000) {
@@ -2656,7 +2656,7 @@ s32 BossHakugin_UpdateDamage(BossHakugin* this, PlayState* play) {
         s32 i;
 
         for (i = 0; i < GOHT_COLLIDER_BODYPART_MAX; i++) {
-            if (this->bodyCollider.elements[i].info.bumperFlags & BUMP_HIT) {
+            if (this->bodyCollider.elements[i].base.bumperFlags & BUMP_HIT) {
                 break;
             }
         }
@@ -2668,7 +2668,7 @@ s32 BossHakugin_UpdateDamage(BossHakugin* this, PlayState* play) {
         // DMG_DEKU_NUT | DMG_DEKU_STICK | DMG_ZORA_BOOMERANG | DMG_NORMAL_ARROW | DMG_HOOKSHOT | DMG_ICE_ARROW
         // | DMG_LIGHT_ARROW | DMG_DEKU_SPIN | DMG_DEKU_BUBBLE | DMG_DEKU_LAUNCH | DMG_ZORA_BARRIER
         if ((this->drawDmgEffType == ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX) &&
-            (this->bodyCollider.elements[i].info.acHitElem->toucher.dmgFlags & 0x000DB0B3)) {
+            (this->bodyCollider.elements[i].base.acHitElem->toucher.dmgFlags & 0x000DB0B3)) {
             return false;
         }
 
@@ -2714,7 +2714,7 @@ s32 BossHakugin_UpdateDamage(BossHakugin* this, PlayState* play) {
             Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_RED, 255, COLORFILTER_BUFFLAG_OPA, 15);
             this->damagedSpeedUpCounter += 35;
             BossHakugin_UpdateDrawDmgEffect(this, play, i);
-            this->actor.colChkInfo.damage = this->bodyCollider.elements[i].info.acHitElem->toucher.damage;
+            this->actor.colChkInfo.damage = this->bodyCollider.elements[i].base.acHitElem->toucher.damage;
 
             if (Actor_ApplyDamage(&this->actor) == 0) {
                 Enemy_StartFinishingBlow(play, &this->actor);
@@ -2724,19 +2724,19 @@ s32 BossHakugin_UpdateDamage(BossHakugin* this, PlayState* play) {
                 if ((this->actor.colChkInfo.damageEffect == GOHT_DMGEFF_EXPLOSIVE) ||
                     ((this->actor.colChkInfo.damageEffect == GOHT_DMGEFF_GORON_SPIKES) &&
                      (this->actionFunc != BossHakugin_Charge) &&
-                     ((this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_HEAD].info.bumperFlags & BUMP_HIT) ||
-                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_THORAX].info.bumperFlags & BUMP_HIT) ||
-                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_PELVIS].info.bumperFlags & BUMP_HIT) ||
-                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_FRONT_RIGHT_UPPER_LEG].info.bumperFlags &
+                     ((this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_HEAD].base.bumperFlags & BUMP_HIT) ||
+                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_THORAX].base.bumperFlags & BUMP_HIT) ||
+                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_PELVIS].base.bumperFlags & BUMP_HIT) ||
+                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_FRONT_RIGHT_UPPER_LEG].base.bumperFlags &
                        BUMP_HIT) ||
-                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_FRONT_LEFT_UPPER_LEG].info.bumperFlags &
+                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_FRONT_LEFT_UPPER_LEG].base.bumperFlags &
                        BUMP_HIT) ||
-                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_BACK_RIGHT_THIGH].info.bumperFlags &
+                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_BACK_RIGHT_THIGH].base.bumperFlags &
                        BUMP_HIT) ||
-                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_BACK_LEFT_THIGH].info.bumperFlags &
+                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_BACK_LEFT_THIGH].base.bumperFlags &
                        BUMP_HIT) ||
-                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_RIGHT_HORN].info.bumperFlags & BUMP_HIT) ||
-                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_LEFT_HORN].info.bumperFlags & BUMP_HIT)))) {
+                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_RIGHT_HORN].base.bumperFlags & BUMP_HIT) ||
+                      (this->bodyCollider.elements[GOHT_COLLIDER_BODYPART_LEFT_HORN].base.bumperFlags & BUMP_HIT)))) {
                     BossHakugin_SetupDowned(this);
                 } else if ((this->electricBallState == GOHT_ELECTRIC_BALL_STATE_NONE) &&
                            (this->electricBallCount == 0) && (this->actionFunc == BossHakugin_Run) &&
@@ -2757,7 +2757,7 @@ s32 BossHakugin_UpdateDamage(BossHakugin* this, PlayState* play) {
             this->disableBodyCollidersTimer = 20;
             for (j = 0; j < ARRAY_COUNT(this->bodyColliderElements); j++) {
                 Vec3f hitPos;
-                ColliderElement* elem = &this->bodyCollider.elements[j].info;
+                ColliderElement* elem = &this->bodyCollider.elements[j].base;
 
                 if ((elem->bumperFlags & BUMP_HIT) && (elem->acHitElem != NULL) &&
                     !(elem->acHitElem->toucherFlags & TOUCH_SFX_NONE)) {
@@ -3778,25 +3778,25 @@ void BossHakugin_SpawnCrushingRocks(BossHakugin* this) {
 void BossHakugin_UpdateCrushingRocksCollision(BossHakugin* this) {
     s32 i;
     GohtCrushingRock* crushingRock;
-    ColliderJntSphElement* element;
+    ColliderJntSphElement* jntSphElem;
 
     for (i = 0; i < GOHT_CRUSHING_ROCK_COUNT / 2; i++) {
         crushingRock = &this->crushingRocks[i << 1];
-        element = &this->bodyCollider.elements[i];
+        jntSphElem = &this->bodyCollider.elements[i];
 
-        element->dim.worldSphere.center.x = crushingRock->pos.x;
-        element->dim.worldSphere.center.y = crushingRock->pos.y;
-        element->dim.worldSphere.center.z = crushingRock->pos.z;
-        element->dim.worldSphere.radius = crushingRock->scale * 3000.0f;
-        element->info.bumper.dmgFlags = 0xF3CFBBFF;
-        element->info.bumperFlags &= ~BUMP_NO_HITMARK;
-        element->info.elemType = ELEMTYPE_UNK0;
+        jntSphElem->dim.worldSphere.center.x = crushingRock->pos.x;
+        jntSphElem->dim.worldSphere.center.y = crushingRock->pos.y;
+        jntSphElem->dim.worldSphere.center.z = crushingRock->pos.z;
+        jntSphElem->dim.worldSphere.radius = crushingRock->scale * 3000.0f;
+        jntSphElem->base.bumper.dmgFlags = 0xF3CFBBFF;
+        jntSphElem->base.bumperFlags &= ~BUMP_NO_HITMARK;
+        jntSphElem->base.elemType = ELEMTYPE_UNK0;
     }
 
     // This for-loop will update the collider for GOHT_COLLIDER_BODYPART_LEFT_HORN.
     for (; i < ARRAY_COUNT(this->bodyColliderElements); i++) {
-        this->bodyCollider.elements[i].info.bumperFlags &= ~BUMP_ON;
-        this->bodyCollider.elements[i].info.ocElemFlags &= ~OCELEM_ON;
+        this->bodyCollider.elements[i].base.bumperFlags &= ~BUMP_ON;
+        this->bodyCollider.elements[i].base.ocElemFlags &= ~OCELEM_ON;
     }
 
     this->bodyCollider.base.colType = COLTYPE_HARD;
diff --git a/src/overlays/actors/ovl_En_Baguo/z_en_baguo.c b/src/overlays/actors/ovl_En_Baguo/z_en_baguo.c
index e77a949fef..1560e4aca3 100644
--- a/src/overlays/actors/ovl_En_Baguo/z_en_baguo.c
+++ b/src/overlays/actors/ovl_En_Baguo/z_en_baguo.c
@@ -356,8 +356,8 @@ void EnBaguo_CheckForDetonation(EnBaguo* this, PlayState* play) {
                 this->actor.flags |= ACTOR_FLAG_CANT_LOCK_ON;
                 this->actor.flags &= ~ACTOR_FLAG_TARGETABLE;
                 Actor_SetScale(&this->actor, 0.0f);
-                this->collider.elements->dim.scale = 3.0f;
-                this->collider.elements->info.toucher.damage = 8;
+                this->collider.elements[0].dim.scale = 3.0f;
+                this->collider.elements[0].base.toucher.damage = 8;
                 Item_DropCollectibleRandom(play, NULL, &this->actor.world.pos, 0xB0);
                 this->actionFunc = EnBaguo_PostDetonation;
             }
diff --git a/src/overlays/actors/ovl_En_Bal/z_en_bal.c b/src/overlays/actors/ovl_En_Bal/z_en_bal.c
index d05a618c76..9523cdc0d9 100644
--- a/src/overlays/actors/ovl_En_Bal/z_en_bal.c
+++ b/src/overlays/actors/ovl_En_Bal/z_en_bal.c
@@ -238,15 +238,15 @@ void EnBal_Destroy(Actor* thisx, PlayState* play) {
 }
 
 void EnBal_SetMainColliderToBalloon(EnBal* this) {
-    this->collider.elements->dim.limb = TINGLE_LIMB_BALLOON;
-    this->collider.elements->dim.modelSphere.radius = 40;
-    this->collider.elements->dim.modelSphere.center.x = 2200;
+    this->collider.elements[0].dim.limb = TINGLE_LIMB_BALLOON;
+    this->collider.elements[0].dim.modelSphere.radius = 40;
+    this->collider.elements[0].dim.modelSphere.center.x = 2200;
 }
 
 void EnBal_SetMainColliderToHead(EnBal* this) {
-    this->collider.elements->dim.limb = TINGLE_LIMB_HEAD;
-    this->collider.elements->dim.modelSphere.radius = 25;
-    this->collider.elements->dim.modelSphere.center.x = 0;
+    this->collider.elements[0].dim.limb = TINGLE_LIMB_HEAD;
+    this->collider.elements[0].dim.modelSphere.radius = 25;
+    this->collider.elements[0].dim.modelSphere.center.x = 0;
 }
 
 s32 EnBal_ValidatePictograph(PlayState* play, Actor* thisx) {
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 9c2f933aee..3d2f56f6b4 100644
--- a/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c
+++ b/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c
@@ -234,15 +234,15 @@ void EnBbfall_CheckForWall(EnBbfall* this) {
 }
 
 void EnBbfall_EnableColliders(EnBbfall* this) {
-    this->collider.elements[0].info.toucher.effect = ELEMTYPE_UNK1; // Fire
-    this->collider.elements[1].info.toucherFlags |= TOUCH_ON;
-    this->collider.elements[2].info.toucherFlags |= TOUCH_ON;
+    this->collider.elements[0].base.toucher.effect = ELEMTYPE_UNK1; // Fire
+    this->collider.elements[1].base.toucherFlags |= TOUCH_ON;
+    this->collider.elements[2].base.toucherFlags |= TOUCH_ON;
 }
 
 void EnBbfall_DisableColliders(EnBbfall* this) {
-    this->collider.elements[0].info.toucher.effect = ELEMTYPE_UNK0; // Nothing
-    this->collider.elements[1].info.toucherFlags &= ~TOUCH_ON;
-    this->collider.elements[2].info.toucherFlags &= ~TOUCH_ON;
+    this->collider.elements[0].base.toucher.effect = ELEMTYPE_UNK0; // Nothing
+    this->collider.elements[1].base.toucherFlags &= ~TOUCH_ON;
+    this->collider.elements[2].base.toucherFlags &= ~TOUCH_ON;
 }
 
 void EnBbfall_SetupWaitForPlayer(EnBbfall* this) {
@@ -524,7 +524,7 @@ void EnBbfall_UpdateDamage(EnBbfall* this, PlayState* play) {
         this->collider.base.atFlags &= ~(AT_HIT | AT_BOUNCED);
         this->collider.base.atFlags &= ~AT_ON;
         if ((this->drawDmgEffType != ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX) ||
-            !(this->collider.elements[0].info.acHitElem->toucher.dmgFlags & 0xDB0B3)) {
+            !(this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0xDB0B3)) {
             Actor_SetDropFlagJntSph(&this->actor, &this->collider);
             this->flameOpacity = 0;
             this->flameScaleY = 0.0f;
@@ -554,9 +554,9 @@ void EnBbfall_UpdateDamage(EnBbfall* this, PlayState* play) {
                 this->drawDmgEffAlpha = 4.0f;
                 this->drawDmgEffScale = 0.4f;
                 this->drawDmgEffType = ACTOR_DRAW_DMGEFF_LIGHT_ORBS;
-                Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->collider.elements[0].info.bumper.hitPos.x,
-                            this->collider.elements[0].info.bumper.hitPos.y,
-                            this->collider.elements[0].info.bumper.hitPos.z, 0, 0, 0,
+                Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->collider.elements[0].base.bumper.hitPos.x,
+                            this->collider.elements[0].base.bumper.hitPos.y,
+                            this->collider.elements[0].base.bumper.hitPos.z, 0, 0, 0,
                             CLEAR_TAG_PARAMS(CLEAR_TAG_SMALL_LIGHT_RAYS));
             }
         }
@@ -613,7 +613,7 @@ void EnBbfall_Update(Actor* thisx, PlayState* play) {
         this->collider.elements[0].dim.worldSphere.radius =
             CLAMP_MIN(this->collider.elements[0].dim.worldSphere.radius, 20);
 
-        Math_Vec3s_ToVec3f(&this->actor.focus.pos, &this->collider.elements->dim.worldSphere.center);
+        Math_Vec3s_ToVec3f(&this->actor.focus.pos, &this->collider.elements[0].dim.worldSphere.center);
 
         if (this->collider.base.atFlags & AT_ON) {
             this->actor.flags |= ACTOR_FLAG_1000000;
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 79188022ce..f33b8c12c2 100644
--- a/src/overlays/actors/ovl_En_Bom/z_en_bom.c
+++ b/src/overlays/actors/ovl_En_Bom/z_en_bom.c
@@ -162,7 +162,7 @@ void EnBom_Init(Actor* thisx, PlayState* play) {
         func_80872648(play, &this->actor.world.pos);
     }
 
-    this->collider2Elements[0].info.toucher.damage += ENBOM_GET_FF00(thisx);
+    this->collider2Elements[0].base.toucher.damage += ENBOM_GET_FF00(thisx);
     this->actor.shape.rot.z &= 0xFF;
     if (ENBOM_GET_80(&this->actor)) {
         this->actor.shape.rot.z |= 0xFF00;
@@ -342,12 +342,12 @@ void EnBom_Explode(EnBom* this, PlayState* play) {
     Color_RGBA8 sp84;
     Color_RGBA8 sp80;
 
-    if (this->collider2.elements->dim.modelSphere.radius == 0) {
+    if (this->collider2.elements[0].dim.modelSphere.radius == 0) {
         this->actor.flags |= ACTOR_FLAG_20;
         Rumble_Request(this->actor.xzDistToPlayer, 255, 20, 150);
     }
 
-    this->collider2.elements->dim.worldSphere.radius = D_80872E8C[this->isPowderKeg];
+    this->collider2.elements[0].dim.worldSphere.radius = D_80872E8C[this->isPowderKeg];
     if (this->timer == 7) {
         this->collider2.base.atFlags &= ~AT_TYPE_ENEMY;
     }
diff --git a/src/overlays/actors/ovl_En_Bombf/z_en_bombf.c b/src/overlays/actors/ovl_En_Bombf/z_en_bombf.c
index 1d8d486d97..c6e39e839a 100644
--- a/src/overlays/actors/ovl_En_Bombf/z_en_bombf.c
+++ b/src/overlays/actors/ovl_En_Bombf/z_en_bombf.c
@@ -261,13 +261,13 @@ void func_808AEF68(EnBombf* this, PlayState* play) {
 }
 
 void func_808AEFD4(EnBombf* this, PlayState* play) {
-    if (this->colliderJntSph.elements->dim.modelSphere.radius == 0) {
+    if (this->colliderJntSph.elements[0].dim.modelSphere.radius == 0) {
         this->actor.flags |= ACTOR_FLAG_20;
         Rumble_Request(this->actor.xzDistToPlayer, 255, 20, 150);
     }
 
-    this->colliderJntSph.elements->dim.modelSphere.radius = 100;
-    this->colliderJntSph.elements->dim.worldSphere.radius = 100;
+    this->colliderJntSph.elements[0].dim.modelSphere.radius = 100;
+    this->colliderJntSph.elements[0].dim.worldSphere.radius = 100;
 
     if (ENBOMBF_GET(&this->actor) == ENBOMBF_1) {
         CollisionCheck_SetAT(play, &play->colChkCtx, &this->colliderJntSph.base);
diff --git a/src/overlays/actors/ovl_En_Bsb/z_en_bsb.c b/src/overlays/actors/ovl_En_Bsb/z_en_bsb.c
index 61bbaaac25..9b4b17d099 100644
--- a/src/overlays/actors/ovl_En_Bsb/z_en_bsb.c
+++ b/src/overlays/actors/ovl_En_Bsb/z_en_bsb.c
@@ -531,7 +531,7 @@ void func_80C0BF2C(EnBsb* this) {
     this->collider.base.colType = COLTYPE_HARD;
 
     for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++) {
-        this->collider.elements[i].info.elemType = ELEMTYPE_UNK2;
+        this->collider.elements[i].base.elemType = ELEMTYPE_UNK2;
     }
 
     this->actor.flags |= ACTOR_FLAG_CANT_LOCK_ON;
@@ -573,7 +573,7 @@ void func_80C0C0F4(EnBsb* this, PlayState* play) {
     this->collider.base.colType = COLTYPE_NONE;
 
     for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++) {
-        this->collider.elements[i].info.elemType = ELEMTYPE_UNK0;
+        this->collider.elements[i].base.elemType = ELEMTYPE_UNK0;
     }
 
     this->unk_02AE = false;
@@ -886,9 +886,9 @@ void func_80C0CDE4(EnBsb* this, PlayState* play) {
     f32 dy;
     f32 dz;
 
-    hitPos.x = this->collider.elements[1].info.bumper.hitPos.x;
-    hitPos.y = this->collider.elements[1].info.bumper.hitPos.y;
-    hitPos.z = this->collider.elements[1].info.bumper.hitPos.z;
+    hitPos.x = this->collider.elements[1].base.bumper.hitPos.x;
+    hitPos.y = this->collider.elements[1].base.bumper.hitPos.y;
+    hitPos.z = this->collider.elements[1].base.bumper.hitPos.z;
 
     dx = hitPos.x - player->actor.world.pos.x;
     dy = hitPos.y - player->actor.world.pos.y;
@@ -1425,8 +1425,8 @@ void func_80C0E618(EnBsb* this, PlayState* play) {
     if ((this->unk_02B4 != 0) && (this->unk_02B4 != 1) && (this->unk_02B4 != 9) && (this->unk_02B4 != 12) &&
         (this->unk_02B4 != 13) && (this->unk_02B4 != 5) && ((this->unk_02B4 != 8) || !this->unk_02DC)) {
         if (!(this->collider.base.atFlags & AT_BOUNCED)) {
-            if (this->collider.elements[1].info.toucherFlags & TOUCH_HIT) {
-                this->collider.elements[1].info.toucherFlags &= ~TOUCH_HIT;
+            if (this->collider.elements[1].base.toucherFlags & TOUCH_HIT) {
+                this->collider.elements[1].base.toucherFlags &= ~TOUCH_HIT;
                 if ((this->unk_02B4 != 11) && (this->unk_02B4 != 7)) {
                     func_80C0D334(this);
                 }
@@ -1524,10 +1524,10 @@ void func_80C0E618(EnBsb* this, PlayState* play) {
                 func_80C0D3C0(this, play);
             } else {
                 for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++) {
-                    if (this->collider.elements[i].info.bumperFlags & BUMP_HIT) {
-                        sp48.x = this->collider.elements[i].info.bumper.hitPos.x;
-                        sp48.y = this->collider.elements[i].info.bumper.hitPos.y;
-                        sp48.z = this->collider.elements[i].info.bumper.hitPos.z;
+                    if (this->collider.elements[i].base.bumperFlags & BUMP_HIT) {
+                        sp48.x = this->collider.elements[i].base.bumper.hitPos.x;
+                        sp48.y = this->collider.elements[i].base.bumper.hitPos.y;
+                        sp48.z = this->collider.elements[i].base.bumper.hitPos.z;
                         CollisionCheck_BlueBlood(play, NULL, &sp48);
                     }
                 }
diff --git a/src/overlays/actors/ovl_En_Bubble/z_en_bubble.c b/src/overlays/actors/ovl_En_Bubble/z_en_bubble.c
index b10bb99136..9f1bca514d 100644
--- a/src/overlays/actors/ovl_En_Bubble/z_en_bubble.c
+++ b/src/overlays/actors/ovl_En_Bubble/z_en_bubble.c
@@ -96,7 +96,7 @@ void EnBubble_SetDimensions(EnBubble* this, f32 dim) {
 }
 
 s32 func_8089F59C(EnBubble* this) {
-    ColliderElement* elem = &this->colliderSphere.elements[0].info;
+    ColliderElement* elem = &this->colliderSphere.elements[0].base;
 
     elem->toucher.dmgFlags = DMG_EXPLOSIVES;
     elem->toucher.effect = 0;
@@ -112,7 +112,7 @@ s32 func_8089F5D0(EnBubble* this) {
 }
 
 void EnBubble_DamagePlayer(EnBubble* this, PlayState* play) {
-    play->damagePlayer(play, -this->colliderSphere.elements[0].info.toucher.damage);
+    play->damagePlayer(play, -this->colliderSphere.elements[0].base.toucher.damage);
     func_800B8E1C(play, &this->actor, 6.0f, this->actor.yawTowardsPlayer, 6.0f);
 }
 
@@ -205,7 +205,7 @@ void EnBubble_Fly(EnBubble* this, PlayState* play) {
     s32 bgId;
     u8 bounceCount;
 
-    if (this->colliderSphere.elements[1].info.bumperFlags & BUMP_HIT) {
+    if (this->colliderSphere.elements[1].base.bumperFlags & BUMP_HIT) {
         bumpActor = this->colliderSphere.base.ac;
         this->normalizedBumpVelocity = bumpActor->velocity;
         EnBubble_Vec3fNormalize(&this->normalizedBumpVelocity);
@@ -283,7 +283,7 @@ s32 func_8089FF30(EnBubble* this) {
         return false;
     }
     this->colliderSphere.base.acFlags &= ~AC_HIT;
-    if (this->colliderSphere.elements[1].info.bumperFlags & BUMP_HIT) {
+    if (this->colliderSphere.elements[1].base.bumperFlags & BUMP_HIT) {
         this->unk1F4.x = this->colliderSphere.base.ac->velocity.x / 10.0f;
         this->unk1F4.y = this->colliderSphere.base.ac->velocity.y / 10.0f;
         this->unk1F4.z = this->colliderSphere.base.ac->velocity.z / 10.0f;
diff --git a/src/overlays/actors/ovl_En_Butte/z_en_butte.c b/src/overlays/actors/ovl_En_Butte/z_en_butte.c
index afa8524234..e5826444cd 100644
--- a/src/overlays/actors/ovl_En_Butte/z_en_butte.c
+++ b/src/overlays/actors/ovl_En_Butte/z_en_butte.c
@@ -432,11 +432,11 @@ void EnButte_Update(Actor* thisx, PlayState* play) {
         Actor_MoveWithGravity(&this->actor);
         Math_StepToF(&this->actor.world.pos.y, this->unk_25C, 0.6f);
         if (this->actor.xyzDistToPlayerSq < 5000.0f) {
-            ColliderJntSphElement* element = &this->collider.elements[0];
+            ColliderJntSphElement* jntSphElem = &this->collider.elements[0];
 
-            element->dim.worldSphere.center.x = this->actor.world.pos.x;
-            element->dim.worldSphere.center.y = this->actor.world.pos.y;
-            element->dim.worldSphere.center.z = this->actor.world.pos.z;
+            jntSphElem->dim.worldSphere.center.x = this->actor.world.pos.x;
+            jntSphElem->dim.worldSphere.center.y = this->actor.world.pos.y;
+            jntSphElem->dim.worldSphere.center.z = this->actor.world.pos.z;
             CollisionCheck_SetOC(play, &play->colChkCtx, &this->collider.base);
         }
         Actor_SetFocus(&this->actor, this->actor.shape.yOffset * this->actor.scale.y);
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 824792e832..22a88a842a 100644
--- a/src/overlays/actors/ovl_En_Crow/z_en_crow.c
+++ b/src/overlays/actors/ovl_En_Crow/z_en_crow.c
@@ -131,7 +131,7 @@ void EnCrow_Init(Actor* thisx, PlayState* play) {
     SkelAnime_InitFlex(play, &this->skelAnime, &gGuaySkel, &gGuayFlyAnim, this->jointTable, this->morphTable,
                        OBJECT_CROW_LIMB_MAX);
     Collider_InitAndSetJntSph(play, &this->collider, &this->actor, &sJntSphInit, this->colliderElements);
-    this->collider.elements->dim.worldSphere.radius = sJntSphInit.elements[0].dim.modelSphere.radius;
+    this->collider.elements[0].dim.worldSphere.radius = sJntSphInit.elements[0].dim.modelSphere.radius;
     CollisionCheck_SetInfo(&this->actor.colChkInfo, &sDamageTable, &sColChkInfoInit);
     ActorShape_Init(&this->actor.shape, 2000.0f, ActorShadow_DrawCircle, 20.0f);
 
@@ -316,9 +316,9 @@ void EnCrow_SetupDamaged(EnCrow* this, PlayState* play) {
         this->drawDmgEffType = ACTOR_DRAW_DMGEFF_LIGHT_ORBS;
         this->drawDmgEffAlpha = 4.0f;
         this->drawDmgEffFrozenSteamScale = 0.5f;
-        Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->collider.elements->info.bumper.hitPos.x,
-                    this->collider.elements->info.bumper.hitPos.y, this->collider.elements->info.bumper.hitPos.z, 0, 0,
-                    0, CLEAR_TAG_PARAMS(CLEAR_TAG_SMALL_LIGHT_RAYS));
+        Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->collider.elements[0].base.bumper.hitPos.x,
+                    this->collider.elements[0].base.bumper.hitPos.y, this->collider.elements[0].base.bumper.hitPos.z, 0,
+                    0, 0, CLEAR_TAG_PARAMS(CLEAR_TAG_SMALL_LIGHT_RAYS));
     } else if (this->actor.colChkInfo.damageEffect == GUAY_DMGEFF_FIRE) {
         this->drawDmgEffType = ACTOR_DRAW_DMGEFF_FIRE;
         this->drawDmgEffAlpha = 4.0f;
@@ -424,10 +424,11 @@ void EnCrow_SetupRespawn(EnCrow* this) {
     if (sDeadCount == GUAY_NUMBER_OF_DEAD_TO_SPAWN_MEGAGUAY) {
         this->actor.params = GUAY_TYPE_MEGA;
         sDeadCount = 0;
-        this->collider.elements->dim.worldSphere.radius = sJntSphInit.elements->dim.modelSphere.radius * 0.03f * 100.0f;
+        this->collider.elements[0].dim.worldSphere.radius =
+            sJntSphInit.elements[0].dim.modelSphere.radius * 0.03f * 100.0f;
     } else {
         this->actor.params = GUAY_TYPE_NORMAL;
-        this->collider.elements->dim.worldSphere.radius = sJntSphInit.elements->dim.modelSphere.radius;
+        this->collider.elements[0].dim.worldSphere.radius = sJntSphInit.elements[0].dim.modelSphere.radius;
     }
     Animation_PlayLoop(&this->skelAnime, &gGuayFlyAnim);
     Math_Vec3f_Copy(&this->actor.world.pos, &this->actor.home.pos);
@@ -468,7 +469,7 @@ void EnCrow_Respawn(EnCrow* this, PlayState* play) {
 void EnCrow_UpdateDamage(EnCrow* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.elements->info);
+        Actor_SetDropFlag(&this->actor, &this->collider.elements[0].base);
 
         if (this->actor.colChkInfo.damageEffect == GUAY_DMGEFF_STUN) {
             EnCrow_SetupTurnAway(this);
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 c2549eb39c..8b5636998d 100644
--- a/src/overlays/actors/ovl_En_Dekubaba/z_en_dekubaba.c
+++ b/src/overlays/actors/ovl_En_Dekubaba/z_en_dekubaba.c
@@ -248,7 +248,7 @@ void EnDekubaba_DisableHitboxes(EnDekubaba* this) {
     s32 i;
 
     for (i = 1; i < ARRAY_COUNT(this->colliderElements); i++) {
-        this->collider.elements[i].info.bumperFlags &= ~BUMP_ON;
+        this->collider.elements[i].base.bumperFlags &= ~BUMP_ON;
     }
 }
 
@@ -268,7 +268,7 @@ void EnDekubaba_UpdateHeadPosition(EnDekubaba* this) {
 }
 
 void EnDekubaba_SetFireLightEffects(EnDekubaba* this, PlayState* play, s32 index) {
-    ColliderJntSphElement* sphElement;
+    ColliderJntSphElement* jntSphElem;
 
     if (this->actor.colChkInfo.damageEffect == DEKUBABA_DMGEFF_FIRE) {
         this->drawDmgEffType = ACTOR_DRAW_DMGEFF_FIRE;
@@ -278,9 +278,9 @@ void EnDekubaba_SetFireLightEffects(EnDekubaba* this, PlayState* play, s32 index
         this->drawDmgEffType = ACTOR_DRAW_DMGEFF_LIGHT_ORBS;
         this->drawDmgEffScale = 0.75f;
         this->drawDmgEffAlpha = 4.0f;
-        sphElement = &this->collider.elements[index];
-        Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, sphElement->info.bumper.hitPos.x,
-                    sphElement->info.bumper.hitPos.y, sphElement->info.bumper.hitPos.z, 0, 0, 0,
+        jntSphElem = &this->collider.elements[index];
+        Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, jntSphElem->base.bumper.hitPos.x,
+                    jntSphElem->base.bumper.hitPos.y, jntSphElem->base.bumper.hitPos.z, 0, 0, 0,
                     CLEAR_TAG_PARAMS(CLEAR_TAG_SMALL_LIGHT_RAYS));
     }
 }
@@ -309,7 +309,7 @@ void EnDekubaba_SpawnIceEffects(EnDekubaba* this, PlayState* play) {
 
 void EnDekubaba_SetupWait(EnDekubaba* this) {
     s32 i;
-    ColliderJntSphElement* element;
+    ColliderJntSphElement* jntSphElem;
 
     this->actor.shape.rot.x = -0x4000;
     this->stemSectionAngle[0] = this->stemSectionAngle[1] = this->stemSectionAngle[2] = this->actor.shape.rot.x;
@@ -325,10 +325,10 @@ void EnDekubaba_SetupWait(EnDekubaba* this) {
     this->timer = 45;
 
     for (i = 1; i < ARRAY_COUNT(this->colliderElements); i++) {
-        element = &this->collider.elements[i];
-        element->dim.worldSphere.center.x = this->actor.world.pos.x;
-        element->dim.worldSphere.center.y = (s32)this->actor.world.pos.y - 7;
-        element->dim.worldSphere.center.z = this->actor.world.pos.z;
+        jntSphElem = &this->collider.elements[i];
+        jntSphElem->dim.worldSphere.center.x = this->actor.world.pos.x;
+        jntSphElem->dim.worldSphere.center.y = (s32)this->actor.world.pos.y - 7;
+        jntSphElem->dim.worldSphere.center.z = this->actor.world.pos.z;
     }
 
     this->actionFunc = EnDekubaba_Wait;
@@ -359,7 +359,7 @@ void EnDekubaba_SetupGrow(EnDekubaba* this) {
     this->timer = 15;
 
     for (i = 2; i < ARRAY_COUNT(this->colliderElements); i++) {
-        this->collider.elements[i].info.ocElemFlags |= OCELEM_ON;
+        this->collider.elements[i].base.ocElemFlags |= OCELEM_ON;
     }
 
     this->collider.base.colType = COLTYPE_HIT6;
@@ -447,7 +447,7 @@ void EnDekubaba_SetupRetract(EnDekubaba* this) {
     this->timer = 15;
 
     for (i = 2; i < ARRAY_COUNT(this->colliderElements); i++) {
-        this->collider.elements[i].info.ocElemFlags &= ~OCELEM_ON;
+        this->collider.elements[i].base.ocElemFlags &= ~OCELEM_ON;
     }
 
     this->actionFunc = EnDekubaba_Retract;
@@ -936,7 +936,7 @@ void EnDekubaba_SetupStunnedVertical(EnDekubaba* this) {
     s32 i;
 
     for (i = 1; i < ARRAY_COUNT(this->colliderElements); i++) {
-        this->collider.elements[i].info.bumperFlags |= BUMP_ON;
+        this->collider.elements[i].base.bumperFlags |= BUMP_ON;
     }
 
     if (this->timer == 1) {
@@ -1068,7 +1068,7 @@ void EnDekubaba_DeadStickDrop(EnDekubaba* this, PlayState* play) {
 void EnDekubaba_UpdateDamage(EnDekubaba* this, PlayState* play) {
     s32 newHealth;
     s32 i;
-    ColliderJntSphElement* sphElement;
+    ColliderJntSphElement* jntSphElem;
 
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
@@ -1076,16 +1076,16 @@ void EnDekubaba_UpdateDamage(EnDekubaba* this, PlayState* play) {
 
         if ((this->collider.base.colType != COLTYPE_HARD) &&
             (this->actor.colChkInfo.damageEffect != DEKUBABA_DMGEFF_HOOKSHOT)) {
-            sphElement = &this->collider.elements[0];
-            for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++, sphElement++) {
-                if (sphElement->info.bumperFlags & BUMP_HIT) {
+            jntSphElem = &this->collider.elements[0];
+            for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++, jntSphElem++) {
+                if (jntSphElem->base.bumperFlags & BUMP_HIT) {
                     break;
                 }
             }
 
             if ((i != ARRAY_COUNT(this->colliderElements)) &&
                 ((this->drawDmgEffType != ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX) ||
-                 !(sphElement->info.acHitElem->toucher.dmgFlags & 0xDB0B3))) {
+                 !(jntSphElem->base.acHitElem->toucher.dmgFlags & 0xDB0B3))) {
                 EnDekubaba_SpawnIceEffects(this, play);
                 newHealth = this->actor.colChkInfo.health - this->actor.colChkInfo.damage;
 
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 7ab4b91420..2f46ec41f8 100644
--- a/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c
+++ b/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c
@@ -427,7 +427,7 @@ void EnDinofos_EnableBumperCollision(EnDinofos* this) {
 
     if (this->isDodgingGoronPound) {
         for (i = 0; i < DINOFOS_COLLIDER_FIRE_START_INDEX; i++) {
-            this->bodyAndFireCollider.elements[i].info.bumper.dmgFlags |= 0x400;
+            this->bodyAndFireCollider.elements[i].base.bumper.dmgFlags |= 0x400;
         }
         this->isDodgingGoronPound = false;
     }
@@ -482,7 +482,7 @@ s32 EnDinofos_Dodge(EnDinofos* this, PlayState* play) {
         (!this->isDodgingGoronPound)) {
         this->isDodgingGoronPound = true;
         for (i = 0; i < DINOFOS_COLLIDER_FIRE_START_INDEX; i++) {
-            this->bodyAndFireCollider.elements[i].info.bumper.dmgFlags &= ~0x400;
+            this->bodyAndFireCollider.elements[i].base.bumper.dmgFlags &= ~0x400;
         }
     }
 
@@ -1296,7 +1296,7 @@ s32 EnDinofos_UpdateDamage(EnDinofos* this, PlayState* play) {
         Actor_SetDropFlagJntSph(&this->actor, &this->bodyAndFireCollider);
 
         for (i = 0; i < ARRAY_COUNT(this->bodyAndFireColliderElements); i++) {
-            if (this->bodyAndFireCollider.elements[i].info.bumperFlags & BUMP_HIT) {
+            if (this->bodyAndFireCollider.elements[i].base.bumperFlags & BUMP_HIT) {
                 break;
             }
         }
@@ -1306,7 +1306,7 @@ s32 EnDinofos_UpdateDamage(EnDinofos* this, PlayState* play) {
         }
 
         if ((this->drawDmgEffType == ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX) &&
-            (this->bodyAndFireCollider.elements[i].info.acHitElem->toucher.dmgFlags & 0xDB0B3)) {
+            (this->bodyAndFireCollider.elements[i].base.acHitElem->toucher.dmgFlags & 0xDB0B3)) {
             return false;
         }
 
@@ -1374,9 +1374,9 @@ s32 EnDinofos_UpdateDamage(EnDinofos* this, PlayState* play) {
             this->drawDmgEffScale = 0.55f;
             this->drawDmgEffType = ACTOR_DRAW_DMGEFF_LIGHT_ORBS;
             Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG,
-                        this->bodyAndFireCollider.elements[i].info.bumper.hitPos.x,
-                        this->bodyAndFireCollider.elements[i].info.bumper.hitPos.y,
-                        this->bodyAndFireCollider.elements[i].info.bumper.hitPos.z, 0, 0, 0,
+                        this->bodyAndFireCollider.elements[i].base.bumper.hitPos.x,
+                        this->bodyAndFireCollider.elements[i].base.bumper.hitPos.y,
+                        this->bodyAndFireCollider.elements[i].base.bumper.hitPos.z, 0, 0, 0,
                         CLEAR_TAG_PARAMS(CLEAR_TAG_LARGE_LIGHT_RAYS));
         }
         EnDinofos_SetupDamaged(this, i);
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 5359b13cd9..7b88f3b7ec 100644
--- a/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
+++ b/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
@@ -315,8 +315,8 @@ void EnDodongo_Init(Actor* thisx, PlayState* play) {
     Collider_InitAndSetJntSph(play, &this->collider3, &this->actor, &sJntSphInit3, this->collider3Elements);
 
     for (i = 0; i < ARRAY_COUNT(this->collider2Elements); i++) {
-        this->collider2.elements[i].info.elemType = ELEMTYPE_UNK2;
-        this->collider2.elements[i].info.bumper.dmgFlags = 0x77C34FE6;
+        this->collider2.elements[i].base.elemType = ELEMTYPE_UNK2;
+        this->collider2.elements[i].base.bumper.dmgFlags = 0x77C34FE6;
     }
 
     Effect_Add(play, &this->unk_338, EFFECT_BLURE2, 0, 0, &D_80879308);
@@ -330,7 +330,7 @@ void EnDodongo_Init(Actor* thisx, PlayState* play) {
 
         for (i = 0; i < ARRAY_COUNT(this->collider1Elements); i++) {
             this->collider1.elements[i].dim.modelSphere.radius *= 2;
-            this->collider1.elements[i].info.toucher.damage *= 2;
+            this->collider1.elements[i].base.toucher.damage *= 2;
         }
 
         for (i = 0; i < ARRAY_COUNT(this->collider2Elements); i++) {
@@ -418,9 +418,9 @@ void func_80876BD0(EnDodongo* this, PlayState* play, s32 arg2) {
         this->drawDmgEffType = ACTOR_DRAW_DMGEFF_LIGHT_ORBS;
         this->drawDmgEffScale = 0.75f;
         this->drawDmgEffAlpha = 4.0f;
-        Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->collider1.elements[arg2].info.bumper.hitPos.x,
-                    this->collider1.elements[arg2].info.bumper.hitPos.y,
-                    this->collider1.elements[arg2].info.bumper.hitPos.z, 0, 0, 0,
+        Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->collider1.elements[arg2].base.bumper.hitPos.x,
+                    this->collider1.elements[arg2].base.bumper.hitPos.y,
+                    this->collider1.elements[arg2].base.bumper.hitPos.z, 0, 0, 0,
                     CLEAR_TAG_PARAMS(CLEAR_TAG_LARGE_LIGHT_RAYS));
     }
 }
@@ -648,7 +648,7 @@ void func_8087784C(EnDodongo* this, PlayState* play) {
     static Vec3f D_80879348 = { 0.0f, 0.9f, 0.0f };
     static Vec3f D_80879354 = { 0.0f, 0.0f, 0.0f };
     s16 frame;
-    ColliderJntSphElement* element;
+    ColliderJntSphElement* jntSphElem;
     s32 i;
     s32 end;
     f32 temp_f2;
@@ -666,18 +666,18 @@ void func_8087784C(EnDodongo* this, PlayState* play) {
             end = 3;
         }
 
-        element = &this->collider3.elements[0];
+        jntSphElem = &this->collider3.elements[0];
         temp_f2 = Math_SinS(this->actor.shape.rot.y) * this->unk_334;
         temp_f12 = Math_CosS(this->actor.shape.rot.y) * this->unk_334;
 
-        for (i = 0; i < end; i++, element++) {
-            element->dim.worldSphere.center.x =
-                this->bodyPartsPos[DODONGO_BODYPART_0].x + (element->dim.modelSphere.center.z * temp_f2);
-            element->dim.worldSphere.center.y =
-                this->bodyPartsPos[DODONGO_BODYPART_0].y + (element->dim.modelSphere.center.y * this->unk_334);
-            element->dim.worldSphere.center.z =
-                this->bodyPartsPos[DODONGO_BODYPART_0].z + (element->dim.modelSphere.center.z * temp_f12);
-            element->dim.worldSphere.radius = element->dim.modelSphere.radius;
+        for (i = 0; i < end; i++, jntSphElem++) {
+            jntSphElem->dim.worldSphere.center.x =
+                this->bodyPartsPos[DODONGO_BODYPART_0].x + (jntSphElem->dim.modelSphere.center.z * temp_f2);
+            jntSphElem->dim.worldSphere.center.y =
+                this->bodyPartsPos[DODONGO_BODYPART_0].y + (jntSphElem->dim.modelSphere.center.y * this->unk_334);
+            jntSphElem->dim.worldSphere.center.z =
+                this->bodyPartsPos[DODONGO_BODYPART_0].z + (jntSphElem->dim.modelSphere.center.z * temp_f12);
+            jntSphElem->dim.worldSphere.radius = jntSphElem->dim.modelSphere.radius;
         }
 
         D_80879354.y = this->unk_334 * -4.5f;
@@ -963,16 +963,16 @@ void EnDodongo_UpdateDamage(EnDodongo* this, PlayState* play) {
         this->collider1.base.acFlags &= ~AC_HIT;
 
         for (i = 0; i < ARRAY_COUNT(this->collider2Elements); i++) {
-            if (this->collider2.elements[i].info.bumperFlags & BUMP_HIT) {
+            if (this->collider2.elements[i].base.bumperFlags & BUMP_HIT) {
                 break;
             }
         }
 
         if ((i != ARRAY_COUNT(this->collider2Elements)) &&
             ((this->drawDmgEffType != ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX) ||
-             !(this->collider2.elements[i].info.acHitElem->toucher.dmgFlags & 0xDB0B3))) {
+             !(this->collider2.elements[i].base.acHitElem->toucher.dmgFlags & 0xDB0B3))) {
             func_80876D28(this, play);
-            Math_Vec3s_ToVec3f(&sp3C, &this->collider2.elements[i].info.bumper.hitPos);
+            Math_Vec3s_ToVec3f(&sp3C, &this->collider2.elements[i].base.bumper.hitPos);
             if (this->actor.colChkInfo.damageEffect == 0xF) {
                 CollisionCheck_BlueBlood(play, NULL, &sp3C);
                 EffectSsHitmark_SpawnFixedScale(play, EFFECT_HITMARK_WHITE, &sp3C);
@@ -987,14 +987,14 @@ void EnDodongo_UpdateDamage(EnDodongo* this, PlayState* play) {
         Actor_SetDropFlagJntSph(&this->actor, &this->collider1);
 
         for (i = 0; i < ARRAY_COUNT(this->collider1Elements); i++) {
-            if (this->collider1.elements[i].info.bumperFlags & BUMP_HIT) {
+            if (this->collider1.elements[i].base.bumperFlags & BUMP_HIT) {
                 break;
             }
         }
 
         if ((i != ARRAY_COUNT(this->collider1Elements)) &&
             ((this->drawDmgEffType != ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX) ||
-             !(this->collider1.elements[i].info.acHitElem->toucher.dmgFlags & 0xDB0B3))) {
+             !(this->collider1.elements[i].base.acHitElem->toucher.dmgFlags & 0xDB0B3))) {
             func_80876D28(this, play);
             if (this->actor.colChkInfo.damageEffect != 0xF) {
                 if (!Actor_ApplyDamage(&this->actor)) {
diff --git a/src/overlays/actors/ovl_En_Dragon/z_en_dragon.c b/src/overlays/actors/ovl_En_Dragon/z_en_dragon.c
index 3dadc45681..dc07829b2a 100644
--- a/src/overlays/actors/ovl_En_Dragon/z_en_dragon.c
+++ b/src/overlays/actors/ovl_En_Dragon/z_en_dragon.c
@@ -619,9 +619,9 @@ void EnDragon_Attack(EnDragon* this, PlayState* play) {
     }
 
     if (((this->state != DEEP_PYTHON_ATTACK_STATE_START) && (curFrame >= this->animEndFrame)) ||
-        !(player->stateFlags2 & PLAYER_STATE2_80) || (this->collider.elements[0].info.bumperFlags & BUMP_HIT) ||
-        (this->collider.elements[1].info.bumperFlags & BUMP_HIT) ||
-        (this->collider.elements[2].info.bumperFlags & BUMP_HIT)) {
+        !(player->stateFlags2 & PLAYER_STATE2_80) || (this->collider.elements[0].base.bumperFlags & BUMP_HIT) ||
+        (this->collider.elements[1].base.bumperFlags & BUMP_HIT) ||
+        (this->collider.elements[2].base.bumperFlags & BUMP_HIT)) {
         player->actor.parent = NULL;
         this->grabWaitTimer = 30;
         CutsceneManager_Stop(this->grabCsId);
@@ -736,12 +736,12 @@ void EnDragon_UpdateDamage(EnDragon* this, PlayState* play) {
     PlayerImpactType playerImpactType;
 
     if (this->action == DEEP_PYTHON_ACTION_EXTEND) {
-        if ((this->collider.elements[2].info.bumperFlags & BUMP_HIT) ||
-            (this->collider.elements[3].info.bumperFlags & BUMP_HIT) ||
-            (this->collider.elements[4].info.bumperFlags & BUMP_HIT) ||
-            (this->collider.elements[5].info.bumperFlags & BUMP_HIT) ||
-            (this->collider.elements[6].info.bumperFlags & BUMP_HIT) ||
-            (this->collider.elements[7].info.bumperFlags & BUMP_HIT)) {
+        if ((this->collider.elements[2].base.bumperFlags & BUMP_HIT) ||
+            (this->collider.elements[3].base.bumperFlags & BUMP_HIT) ||
+            (this->collider.elements[4].base.bumperFlags & BUMP_HIT) ||
+            (this->collider.elements[5].base.bumperFlags & BUMP_HIT) ||
+            (this->collider.elements[6].base.bumperFlags & BUMP_HIT) ||
+            (this->collider.elements[7].base.bumperFlags & BUMP_HIT)) {
             Actor_ApplyDamage(&this->actor);
             Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_RED, 255, COLORFILTER_BUFFLAG_OPA, 25);
             if (this->actor.colChkInfo.health > 0) {
@@ -760,7 +760,7 @@ void EnDragon_UpdateDamage(EnDragon* this, PlayState* play) {
     }
 
     if ((this->action == DEEP_PYTHON_ACTION_EXTEND) && (this->grabWaitTimer == 0) &&
-        (player->invincibilityTimer == 0) && (this->collider.elements[0].info.ocElemFlags & OCELEM_HIT) &&
+        (player->invincibilityTimer == 0) && (this->collider.elements[0].base.ocElemFlags & OCELEM_HIT) &&
         !((Actor_GetPlayerImpact(play, 1000.0f, &this->actor.world.pos, &playerImpactType) >= 0.0f) &&
           (playerImpactType == PLAYER_IMPACT_ZORA_BARRIER))) {
         this->actor.speed = 0.0f;
diff --git a/src/overlays/actors/ovl_En_Egol/z_en_egol.c b/src/overlays/actors/ovl_En_Egol/z_en_egol.c
index 559096f656..c348554618 100644
--- a/src/overlays/actors/ovl_En_Egol/z_en_egol.c
+++ b/src/overlays/actors/ovl_En_Egol/z_en_egol.c
@@ -960,8 +960,8 @@ void EnEgol_Punch(EnEgol* this, PlayState* play) {
         this->bodyCollider.elements[1].dim.modelSphere.radius = 20;
         EnEgol_SetupWalk(this);
     } else if (!this->hitPlayer) {
-        if ((this->bodyCollider.elements[0].info.toucherFlags & TOUCH_HIT) ||
-            (this->bodyCollider.elements[1].info.toucherFlags & TOUCH_HIT)) {
+        if ((this->bodyCollider.elements[0].base.toucherFlags & TOUCH_HIT) ||
+            (this->bodyCollider.elements[1].base.toucherFlags & TOUCH_HIT)) {
             this->hitPlayer = true;
             func_800B8D50(play, &this->actor, 10.0f, this->actor.home.rot.y, 10.0f, 0);
         }
@@ -974,7 +974,7 @@ void EnEgol_Punch(EnEgol* this, PlayState* play) {
 void EnEgol_SetupSlamWait(EnEgol* this) {
     EnEgol_ChangeAnim(this, EYEGORE_ANIM_SLAM_WAIT);
     this->actionTimer = 0;
-    this->eyeCollider.elements[0].info.elemType = ELEMTYPE_UNK1;
+    this->eyeCollider.elements[0].base.elemType = ELEMTYPE_UNK1;
     this->action = EYEGORE_ACTION_SLAM_WAIT;
     this->actionFunc = EnEgol_SlamWait;
 }
@@ -985,7 +985,7 @@ void EnEgol_SlamWait(EnEgol* this, PlayState* play) {
     if (curFrame >= this->animEndFrame) {
         this->actionTimer++;
         if (this->actionTimer > 20) {
-            this->eyeCollider.elements[0].info.elemType = ELEMTYPE_UNK2;
+            this->eyeCollider.elements[0].base.elemType = ELEMTYPE_UNK2;
             EnEgol_SetupSlamEnd(this);
         }
     }
@@ -994,7 +994,7 @@ void EnEgol_SlamWait(EnEgol* this, PlayState* play) {
 void EnEgol_SetupStunned(EnEgol* this) {
     EnEgol_ChangeAnim(this, EYEGORE_ANIM_STUNNED);
     this->actionTimer = 0;
-    this->eyeCollider.elements[0].info.elemType = ELEMTYPE_UNK1;
+    this->eyeCollider.elements[0].base.elemType = ELEMTYPE_UNK1;
     this->bodyCollider.elements[0].dim.modelSphere.radius = 0;
     this->bodyCollider.elements[1].dim.modelSphere.radius = 0;
     this->action = EYEGORE_ACTION_STUNNED;
@@ -1007,7 +1007,7 @@ void EnEgol_Stunned(EnEgol* this, PlayState* play) {
     if (curFrame >= this->animEndFrame) {
         this->actionTimer++;
         if (this->actionTimer > 80) {
-            this->eyeCollider.elements->info.elemType = ELEMTYPE_UNK2;
+            this->eyeCollider.elements[0].base.elemType = ELEMTYPE_UNK2;
             EnEgol_SetupStunEnd(this);
         }
     }
@@ -1148,7 +1148,7 @@ void EnEgol_CollisionCheck(EnEgol* this, PlayState* play) {
         Math_Vec3f_Copy(&this->laserCollider.dim.quad[2], &this->laserBase);
         EnEgol_SetupWalk(this);
     }
-    if (this->eyeCollider.elements[0].info.bumperFlags & BUMP_HIT) {
+    if (this->eyeCollider.elements[0].base.bumperFlags & BUMP_HIT) {
         reaction = EYEGORE_HIT_IMMUNE;
         switch (this->actor.colChkInfo.damageEffect) {
             case EYEGORE_DMGEFF_LIGHT_ARROW:
@@ -1201,9 +1201,9 @@ void EnEgol_CollisionCheck(EnEgol* this, PlayState* play) {
     } else if (reaction == EYEGORE_HIT_IMMUNE) {
         Vec3f hitPos;
 
-        hitPos.x = this->eyeCollider.elements[0].info.bumper.hitPos.x;
-        hitPos.y = this->eyeCollider.elements[0].info.bumper.hitPos.y;
-        hitPos.z = this->eyeCollider.elements[0].info.bumper.hitPos.z;
+        hitPos.x = this->eyeCollider.elements[0].base.bumper.hitPos.x;
+        hitPos.y = this->eyeCollider.elements[0].base.bumper.hitPos.y;
+        hitPos.z = this->eyeCollider.elements[0].base.bumper.hitPos.z;
         Actor_PlaySfx(&this->actor, NA_SE_IT_SHIELD_BOUND);
         EffectSsHitmark_SpawnFixedScale(play, EFFECT_HITMARK_METAL, &hitPos);
         CollisionCheck_SpawnShieldParticlesMetal(play, &hitPos);
diff --git a/src/overlays/actors/ovl_En_Encount2/z_en_encount2.c b/src/overlays/actors/ovl_En_Encount2/z_en_encount2.c
index 8b49b44e17..e6d66a0f2a 100644
--- a/src/overlays/actors/ovl_En_Encount2/z_en_encount2.c
+++ b/src/overlays/actors/ovl_En_Encount2/z_en_encount2.c
@@ -126,11 +126,11 @@ void EnEncount2_Init(Actor* thisx, PlayState* play) {
         return;
     }
 
-    this->collider.elements->dim.modelSphere.radius = 57;
-    this->collider.elements->dim.scale = 1.0f;
-    this->collider.elements->dim.modelSphere.center.x = 0;
-    this->collider.elements->dim.modelSphere.center.y = -4;
-    this->collider.elements->dim.modelSphere.center.z = 0;
+    this->collider.elements[0].dim.modelSphere.radius = 57;
+    this->collider.elements[0].dim.scale = 1.0f;
+    this->collider.elements[0].dim.modelSphere.center.x = 0;
+    this->collider.elements[0].dim.modelSphere.center.y = -4;
+    this->collider.elements[0].dim.modelSphere.center.z = 0;
 
     this->dyna.actor.colChkInfo.damageTable = &sDamageTable;
     EnEncount2_SetupIdle(this);
diff --git a/src/overlays/actors/ovl_En_Fish/z_en_fish.c b/src/overlays/actors/ovl_En_Fish/z_en_fish.c
index 1f35f401f1..8e2216edba 100644
--- a/src/overlays/actors/ovl_En_Fish/z_en_fish.c
+++ b/src/overlays/actors/ovl_En_Fish/z_en_fish.c
@@ -867,12 +867,12 @@ void func_8091F5A4(Actor* thisx, PlayState* play) {
         }
 
         if ((this->actor.xzDistToPlayer < 70.0f) && (this->unkFunc != func_8091EFE8)) {
-            ColliderJntSphElement* element = &this->collider.elements[0];
+            ColliderJntSphElement* jntSphElem = &this->collider.elements[0];
 
-            element->dim.worldSphere.center.x = this->actor.world.pos.x;
-            element->dim.worldSphere.center.y = this->actor.world.pos.y;
-            element->dim.worldSphere.center.z = this->actor.world.pos.z;
-            element->dim.worldSphere.radius = this->unk_25C * 500.0f;
+            jntSphElem->dim.worldSphere.center.x = this->actor.world.pos.x;
+            jntSphElem->dim.worldSphere.center.y = this->actor.world.pos.y;
+            jntSphElem->dim.worldSphere.center.z = this->actor.world.pos.z;
+            jntSphElem->dim.worldSphere.radius = this->unk_25C * 500.0f;
             CollisionCheck_SetOC(play, &play->colChkCtx, &this->collider.base);
         }
 
diff --git a/src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c b/src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c
index a50058b2cc..50d1f600ce 100644
--- a/src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c
+++ b/src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c
@@ -137,12 +137,12 @@ void func_8093E91C(EnGoroiwa* this) {
 }
 
 void func_8093E938(EnGoroiwa* this) {
-    Sphere16* worldSphere = &this->collider.elements->dim.worldSphere;
+    Sphere16* worldSphere = &this->collider.elements[0].dim.worldSphere;
 
     worldSphere->center.x = this->actor.world.pos.x;
     worldSphere->center.y = this->actor.world.pos.y + this->unk_1DC;
     worldSphere->center.z = this->actor.world.pos.z;
-    this->collider.elements->dim.worldSphere.radius = this->unk_1DC - 1.0f;
+    this->collider.elements[0].dim.worldSphere.radius = this->unk_1DC - 1.0f;
 }
 
 void func_8093E9B0(EnGoroiwa* this, PlayState* play) {
@@ -155,12 +155,12 @@ void func_8093E9B0(EnGoroiwa* this, PlayState* play) {
     this->collider.elements[0].dim.worldSphere.radius = this->unk_1DC - 1.0f;
 
     if ((params == ENGOROIWA_C000_1) || (params == ENGOROIWA_C000_2)) {
-        this->collider.elements[0].info.bumper.dmgFlags |= (0x4000 | 0x400 | 0x100);
+        this->collider.elements[0].base.bumper.dmgFlags |= (0x4000 | 0x400 | 0x100);
         if (params == ENGOROIWA_C000_1) {
             this->collider.base.colType = COLTYPE_WOOD;
         } else {
-            this->collider.elements[0].info.bumper.dmgFlags &= ~(0x400000 | 0x200 | 0x2);
-            this->collider.elements[0].info.bumper.dmgFlags |= (0x80000000 | 0x800 | 0x8);
+            this->collider.elements[0].base.bumper.dmgFlags &= ~(0x400000 | 0x200 | 0x2);
+            this->collider.elements[0].base.bumper.dmgFlags |= (0x80000000 | 0x800 | 0x8);
             this->collider.base.colType = COLTYPE_NONE;
         }
     }
@@ -923,7 +923,7 @@ void func_80941060(EnGoroiwa* this, PlayState* play) {
     Vec3f spAC;
     Vec3f spA0;
     Vec3f sp94;
-    Vec3s* vec = &this->collider.elements[0].info.bumper.hitPos;
+    Vec3s* vec = &this->collider.elements[0].base.bumper.hitPos;
     s32 i;
 
     for (i = 0; i < 4; i++) {
@@ -1028,7 +1028,7 @@ s32 func_8094156C(EnGoroiwa* this, PlayState* play) {
     Vec3f sp80;
 
     if ((this->collider.base.acFlags & AC_HIT) && ((params == ENGOROIWA_C000_1) || (params == ENGOROIWA_C000_2))) {
-        if (this->collider.elements->info.acHitElem->toucher.dmgFlags & 0x4000) {
+        if (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x4000) {
             s16 sp7E = BINANG_SUB(actor->yawTowardsPlayer, this->actor.world.rot.y);
             f32 temp;
             f32 temp2;
@@ -1082,11 +1082,11 @@ s32 func_8094156C(EnGoroiwa* this, PlayState* play) {
             func_80941274(this, play);
             phi_s0_2 = true;
         } else if (((params == ENGOROIWA_C000_1) &&
-                    (this->collider.elements->info.acHitElem->toucher.dmgFlags & (0x400 | 0x100))) ||
-                   ((params == ENGOROIWA_C000_2) && (this->collider.elements->info.acHitElem->toucher.dmgFlags &
+                    (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & (0x400 | 0x100))) ||
+                   ((params == ENGOROIWA_C000_2) && (this->collider.elements[0].base.acHitElem->toucher.dmgFlags &
                                                      (0x80000000 | 0x800 | 0x400 | 0x100 | 0x8)))) {
             this->unk_1CC = 50;
-            if ((params == ENGOROIWA_C000_2) && (this->collider.elements->info.acHitElem->toucher.dmgFlags & 0x800)) {
+            if ((params == ENGOROIWA_C000_2) && (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x800)) {
                 this->unk_1E6 = true;
             }
             func_80940090(this, play);
diff --git a/src/overlays/actors/ovl_En_Grasshopper/z_en_grasshopper.c b/src/overlays/actors/ovl_En_Grasshopper/z_en_grasshopper.c
index 9fed0d0d48..4e0c6cf423 100644
--- a/src/overlays/actors/ovl_En_Grasshopper/z_en_grasshopper.c
+++ b/src/overlays/actors/ovl_En_Grasshopper/z_en_grasshopper.c
@@ -438,7 +438,7 @@ void EnGrasshopper_Fly(EnGrasshopper* this, PlayState* play) {
         collisionCheckPos.y = this->actor.world.pos.y;
         collisionCheckPos.z = (Math_CosS(this->actor.shape.rot.y) * 100.0f) + this->actor.world.pos.z;
 
-        if (this->collider.elements[0].info.ocElemFlags & OCELEM_HIT) {
+        if (this->collider.elements[0].base.ocElemFlags & OCELEM_HIT) {
             this->shouldTurn = true;
         }
 
@@ -526,10 +526,10 @@ void EnGrasshopper_RoamInCircles(EnGrasshopper* this, PlayState* play) {
             BgCheck_SphVsFirstPoly(&play->colCtx, &collisionCheckPos, 10.0f)) {
             EnGrasshopper_SetupBank(this);
         } else if (player->stateFlags1 & PLAYER_STATE1_8000000) {
-            this->collider.elements[0].info.toucherFlags |= (TOUCH_ON | TOUCH_SFX_WOOD);
+            this->collider.elements[0].base.toucherFlags |= (TOUCH_ON | TOUCH_SFX_WOOD);
             EnGrasshopper_RaiseTail(this);
         } else if (this->collider.base.atFlags & AT_BOUNCED) {
-            this->collider.elements[0].info.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
+            this->collider.elements[0].base.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
             EnGrasshopper_SetupBounced(this);
         } else {
             this->targetRot.z = (this->actor.world.rot.y - this->targetRot.y) * 0.2f;
@@ -612,7 +612,7 @@ void EnGrasshopper_Bounced(EnGrasshopper* this, PlayState* play) {
     this->targetRot.z *= 0.8f;
     Math_SmoothStepToS(&this->actor.world.rot.y, this->targetRot.y, 5, this->angularVelocity, 5);
     if (this->timer == 0) {
-        this->collider.elements[0].info.toucherFlags |= (TOUCH_ON | TOUCH_SFX_WOOD);
+        this->collider.elements[0].base.toucherFlags |= (TOUCH_ON | TOUCH_SFX_WOOD);
         this->timer = 0;
         this->action = DRAGONFLY_ACTION_ROAM_IN_CIRCLES;
         this->waitTimer = this->timer;
@@ -681,8 +681,8 @@ void EnGrasshopper_SetupAttack(EnGrasshopper* this) {
     Math_SmoothStepToS(&this->actor.world.rot.y, this->actor.yawTowardsPlayer, 0xA, 0xFA0, 0xA);
     this->actor.speed = 3.0f;
     this->baseFlyHeight = this->actor.world.pos.y;
-    this->collider.elements[0].info.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
-    this->collider.elements[1].info.toucherFlags |= (TOUCH_ON | TOUCH_SFX_WOOD);
+    this->collider.elements[0].base.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
+    this->collider.elements[1].base.toucherFlags |= (TOUCH_ON | TOUCH_SFX_WOOD);
     Actor_PlaySfx(&this->actor, NA_SE_EN_BATTA_ATTACK);
     this->action = DRAGONFLY_ACTION_ATTACK;
     this->actionFunc = EnGrasshopper_Attack;
@@ -721,9 +721,9 @@ void EnGrasshopper_Attack(EnGrasshopper* this, PlayState* play) {
     this->bobPhase += 0xAF0;
     this->targetApproachPos.y = (Math_SinS(this->bobPhase) * 10.0f) + (player->actor.world.pos.y + 60.0f);
 
-    hitPos.x = this->collider.elements[1].info.bumper.hitPos.x;
-    hitPos.y = this->collider.elements[1].info.bumper.hitPos.y;
-    hitPos.z = this->collider.elements[1].info.bumper.hitPos.z;
+    hitPos.x = this->collider.elements[1].base.bumper.hitPos.x;
+    hitPos.y = this->collider.elements[1].base.bumper.hitPos.y;
+    hitPos.z = this->collider.elements[1].base.bumper.hitPos.z;
     diff.x = hitPos.x - player->actor.world.pos.x;
     diff.y = hitPos.y - player->actor.world.pos.y;
     diff.z = hitPos.z - player->actor.world.pos.z;
@@ -733,7 +733,7 @@ void EnGrasshopper_Attack(EnGrasshopper* this, PlayState* play) {
         ((player->stateFlags1 & PLAYER_STATE1_400000) && (playerToHitPosDist <= 60.0f) &&
          ((s16)((player->actor.shape.rot.y - this->actor.shape.rot.y) + 0x8000) < 0x2000) &&
          ((s16)((player->actor.shape.rot.y - this->actor.shape.rot.y) + 0x8000) > -0x2000))) {
-        this->collider.elements[1].info.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
+        this->collider.elements[1].base.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
     }
 
     Math_ApproachF(&this->actor.world.pos.y, this->targetApproachPos.y, 0.1f, this->approachSpeed);
@@ -752,7 +752,7 @@ void EnGrasshopper_SetupWaitAfterAttack(EnGrasshopper* this) {
     this->action = DRAGONFLY_ACTION_WAIT_AFTER_ATTACK;
     this->waitTimer = 20;
     this->actor.speed = 0.0f;
-    this->collider.elements[1].info.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
+    this->collider.elements[1].base.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
     this->actionFunc = EnGrasshopper_WaitAfterAttack;
 }
 
@@ -764,7 +764,7 @@ void EnGrasshopper_WaitAfterAttack(EnGrasshopper* this, PlayState* play) {
     this->targetPosY = (Math_SinS(this->bobPhase) * 10.0f) + this->baseFlyHeight;
     Math_ApproachF(&this->actor.world.pos.y, this->targetPosY, 0.1f, 10.0f);
     if (this->waitTimer == 0) {
-        this->collider.elements[0].info.toucherFlags |= (TOUCH_ON | TOUCH_SFX_WOOD);
+        this->collider.elements[0].base.toucherFlags |= (TOUCH_ON | TOUCH_SFX_WOOD);
         EnGrasshopper_RaiseTail(this);
     }
 }
@@ -776,7 +776,7 @@ void EnGrasshopper_SetupDamaged(EnGrasshopper* this, PlayState* play) {
     this->actor.speed = 0.0f;
     this->actor.flags |= ACTOR_FLAG_TARGETABLE;
     this->approachSpeed = 0.0f;
-    this->collider.elements[1].info.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
+    this->collider.elements[1].base.toucherFlags &= ~(TOUCH_ON | TOUCH_SFX_WOOD);
     Matrix_RotateYS(this->actor.yawTowardsPlayer, MTXMODE_NEW);
     Matrix_MultVecZ(-20.0f, &damagedVelocity);
     Math_Vec3f_Copy(&this->damagedVelocity, &damagedVelocity);
@@ -924,8 +924,8 @@ void EnGrasshopper_UpdateDamage(EnGrasshopper* this, PlayState* play) {
     s32 pad;
     s16 attackDealsDamage = false;
 
-    if ((this->collider.elements[0].info.bumperFlags & BUMP_HIT) ||
-        (this->collider.elements[1].info.bumperFlags & BUMP_HIT)) {
+    if ((this->collider.elements[0].base.bumperFlags & BUMP_HIT) ||
+        (this->collider.elements[1].base.bumperFlags & BUMP_HIT)) {
         this->collider.base.acFlags &= ~AC_HIT;
         if ((this->action != DRAGONFLY_ACTION_DAMAGED) && (this->action != DRAGONFLY_ACTION_DEAD) &&
             (this->action != DRAGONFLY_ACTION_FALL)) {
diff --git a/src/overlays/actors/ovl_En_Horse/z_en_horse.c b/src/overlays/actors/ovl_En_Horse/z_en_horse.c
index fb285a9dd0..e54ea97792 100644
--- a/src/overlays/actors/ovl_En_Horse/z_en_horse.c
+++ b/src/overlays/actors/ovl_En_Horse/z_en_horse.c
@@ -372,7 +372,7 @@ void func_8087B7C0(EnHorse* this, PlayState* play, Path* path) {
         EnHorse_RotateToPoint(this, play, &sp8C, 0x320);
         if (sp70 < SQ(100.0f)) {
             if ((this->actor.xzDistToPlayer < 100.0f) ||
-                (this->colliderJntSph.elements[0].info.ocElemFlags & OCELEM_HIT)) {
+                (this->colliderJntSph.elements[0].base.ocElemFlags & OCELEM_HIT)) {
                 s32 pad;
 
                 if (Math_SinS(this->actor.yawTowardsPlayer - this->actor.world.rot.y) > 0.0f) {
@@ -4275,7 +4275,7 @@ void EnHorse_Update(Actor* thisx, PlayState* play2) {
             }
         }
 
-        if (this->colliderJntSph.elements->info.ocElemFlags & OCELEM_HIT) {
+        if (this->colliderJntSph.elements[0].base.ocElemFlags & OCELEM_HIT) {
             if (thisx->speed > 10.0f) {
                 thisx->speed -= 1.0f;
             }
@@ -4295,7 +4295,7 @@ void EnHorse_Update(Actor* thisx, PlayState* play2) {
         }
 
         if ((this->playerControlled == false) && (this->unk_1EC & 8)) {
-            if ((this->colliderJntSph.elements->info.ocElemFlags & OCELEM_HIT) &&
+            if ((this->colliderJntSph.elements[0].base.ocElemFlags & OCELEM_HIT) &&
                 (this->colliderJntSph.base.oc->id == ACTOR_EN_IN)) {
                 func_80884868(this);
             }
diff --git a/src/overlays/actors/ovl_En_Insect/z_en_insect.c b/src/overlays/actors/ovl_En_Insect/z_en_insect.c
index 427a0a6f10..068393f457 100644
--- a/src/overlays/actors/ovl_En_Insect/z_en_insect.c
+++ b/src/overlays/actors/ovl_En_Insect/z_en_insect.c
@@ -137,9 +137,9 @@ void EnInsect_Init(Actor* thisx, PlayState* play) {
     Collider_SetJntSph(play, &this->collider, &this->actor, &sJntSphInit, this->colliderElements);
 
     {
-        ColliderJntSphElement* colliderElement = &this->collider.elements[0];
+        ColliderJntSphElement* jntSphElem = &this->collider.elements[0];
 
-        colliderElement->dim.worldSphere.radius = colliderElement->dim.modelSphere.radius * colliderElement->dim.scale;
+        jntSphElem->dim.worldSphere.radius = jntSphElem->dim.modelSphere.radius * jntSphElem->dim.scale;
     }
 
     this->actor.colChkInfo.mass = 30;
@@ -486,11 +486,11 @@ void EnInsect_Update(Actor* thisx, PlayState* play) {
             func_8091B274(this);
         } else if ((this->actor.xzDistToPlayer < 50.0f) && (this->actionFunc != func_8091B2D8)) {
             if (!(this->unk_30C & 0x20) && (this->unk_314 < 180)) {
-                ColliderJntSphElement* colliderElement = &this->collider.elements[0];
+                ColliderJntSphElement* jntSphElem = &this->collider.elements[0];
 
-                colliderElement->dim.worldSphere.center.x = this->actor.world.pos.x;
-                colliderElement->dim.worldSphere.center.y = this->actor.world.pos.y;
-                colliderElement->dim.worldSphere.center.z = this->actor.world.pos.z;
+                jntSphElem->dim.worldSphere.center.x = this->actor.world.pos.x;
+                jntSphElem->dim.worldSphere.center.y = this->actor.world.pos.y;
+                jntSphElem->dim.worldSphere.center.z = this->actor.world.pos.z;
                 CollisionCheck_SetOC(play, &play->colChkCtx, &this->collider.base);
             }
 
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 96cc2d329c..bd3e62d334 100644
--- a/src/overlays/actors/ovl_En_Knight/z_en_knight.c
+++ b/src/overlays/actors/ovl_En_Knight/z_en_knight.c
@@ -1586,8 +1586,8 @@ void EnKnight_FallOver(EnKnight* this, PlayState* play) {
         } else {
             this->actor.colChkInfo.health = 6 - BREG(40);
         }
-        this->bodyCollider.elements[0].info.bumperFlags &= ~BUMP_HIT;
-        this->bodyCollider.elements[1].info.bumperFlags &= ~BUMP_HIT;
+        this->bodyCollider.elements[0].base.bumperFlags &= ~BUMP_HIT;
+        this->bodyCollider.elements[1].base.bumperFlags &= ~BUMP_HIT;
         this->actor.colChkInfo.damageTable = &sDamageTableStanding;
         this->invincibilityTimer = 25;
     }
@@ -3059,8 +3059,8 @@ void EnKnight_UpdateDamage(EnKnight* this, PlayState* play) {
     Vec3f translation;
     Player* player = GET_PLAYER(play);
 
-    if (this->shieldCollider.elements[0].info.bumperFlags & BUMP_HIT) {
-        this->shieldCollider.elements[0].info.bumperFlags &= ~BUMP_HIT;
+    if (this->shieldCollider.elements[0].base.bumperFlags & BUMP_HIT) {
+        this->shieldCollider.elements[0].base.bumperFlags &= ~BUMP_HIT;
         this->shieldingInvulnerabilityTimer = 5;
 
         if ((player->meleeWeaponState != PLAYER_MWA_FORWARD_SLASH_1H) &&
@@ -3081,8 +3081,8 @@ void EnKnight_UpdateDamage(EnKnight* this, PlayState* play) {
             continue;
         }
 
-        if (this->bodyCollider.elements[i].info.bumperFlags & BUMP_HIT) {
-            this->bodyCollider.elements[i].info.bumperFlags &= ~BUMP_HIT;
+        if (this->bodyCollider.elements[i].base.bumperFlags & BUMP_HIT) {
+            this->bodyCollider.elements[i].base.bumperFlags &= ~BUMP_HIT;
 
             switch (this->actor.colChkInfo.damageEffect) {
                 case KNIGHT_DMGEFF_ICE:
@@ -3159,13 +3159,13 @@ void EnKnight_UpdateDamageFallenOver(EnKnight* this, PlayState* play) {
     }
 
     for (i = 0; i < ARRAY_COUNT(this->bodyColliderElements); i++) {
-        ColliderJntSphElement* colliderElem = &this->bodyCollider.elements[i];
+        ColliderJntSphElement* jntSphElem = &this->bodyCollider.elements[i];
         ColliderElement* acHitElem;
 
-        if (colliderElem->info.bumperFlags & BUMP_HIT) {
-            colliderElem->info.bumperFlags &= ~BUMP_HIT;
+        if (jntSphElem->base.bumperFlags & BUMP_HIT) {
+            jntSphElem->base.bumperFlags &= ~BUMP_HIT;
 
-            acHitElem = colliderElem->info.acHitElem;
+            acHitElem = jntSphElem->base.acHitElem;
 
             this->invincibilityTimer = 10;
             if (acHitElem->toucher.dmgFlags & DMG_LIGHT_RAY) {
diff --git a/src/overlays/actors/ovl_En_Minideath/z_en_minideath.c b/src/overlays/actors/ovl_En_Minideath/z_en_minideath.c
index 90e31d382f..394aa60aad 100644
--- a/src/overlays/actors/ovl_En_Minideath/z_en_minideath.c
+++ b/src/overlays/actors/ovl_En_Minideath/z_en_minideath.c
@@ -301,8 +301,8 @@ void EnMinideath_UpdateEffects(EnMinideath* this, PlayState* play) {
             } else if (this->actionFunc == EnMinideath_CrowdParent) {
                 Math_Vec3f_Diff(&this->actor.parent->focus.pos, &this->actor.world.pos, &effect->vel);
                 effect->state = 0;
-                this->collider.elements[i].info.bumperFlags |= BUMP_ON;
-                this->collider.elements[i].info.toucherFlags |= TOUCH_ON;
+                this->collider.elements[i].base.bumperFlags |= BUMP_ON;
+                this->collider.elements[i].base.toucherFlags |= TOUCH_ON;
                 phi_s7 = 1;
                 phi_s3++;
             }
@@ -754,9 +754,9 @@ void EnMinideath_UpdateDamage(EnMinideath* this, PlayState* play) {
             s32 phi_a0;
 
             for (i = 0; i < MINIDEATH_NUM_EFFECTS; i++) {
-                if (this->collider.elements[i].info.bumperFlags & BUMP_HIT) {
-                    this->collider.elements[i].info.bumperFlags &= ~(BUMP_ON | BUMP_HIT);
-                    this->collider.elements[i].info.toucherFlags &= ~(TOUCH_ON | TOUCH_HIT);
+                if (this->collider.elements[i].base.bumperFlags & BUMP_HIT) {
+                    this->collider.elements[i].base.bumperFlags &= ~(BUMP_ON | BUMP_HIT);
+                    this->collider.elements[i].base.toucherFlags &= ~(TOUCH_ON | TOUCH_HIT);
                     this->effects[i].vel.y = -1.0f;
                     this->effects[i].state = 1;
                     this->effects[i].angle.y = this->actor.shape.rot.y;
@@ -791,7 +791,7 @@ void EnMinideath_UpdateDamage(EnMinideath* this, PlayState* play) {
 void EnMinideath_Update(Actor* thisx, PlayState* play) {
     EnMinideath* this = THIS;
     s32 pad;
-    ColliderJntSphElement* elem;
+    ColliderJntSphElement* jntSphElem;
     s32 temp;
     s32 i;
     MiniDeathEffect* effect;
@@ -834,8 +834,8 @@ void EnMinideath_Update(Actor* thisx, PlayState* play) {
 
         Actor_SetFocus(&this->actor, 0.0f);
 
-        effect = this->effects;
-        elem = this->collider.elements;
+        effect = &this->effects[0];
+        jntSphElem = &this->collider.elements[0];
         for (i = 0; i != MINIDEATH_NUM_EFFECTS; i++) {
             if (effect->state == 0) {
                 Math_Vec3f_Sum(&this->actor.world.pos, &effect->vel, &effect->pos);
@@ -847,12 +847,12 @@ void EnMinideath_Update(Actor* thisx, PlayState* play) {
                     }
                 }
 
-                elem->dim.worldSphere.center.x = effect->pos.x;
-                elem->dim.worldSphere.center.y = effect->pos.y;
-                elem->dim.worldSphere.center.z = effect->pos.z;
+                jntSphElem->dim.worldSphere.center.x = effect->pos.x;
+                jntSphElem->dim.worldSphere.center.y = effect->pos.y;
+                jntSphElem->dim.worldSphere.center.z = effect->pos.z;
             }
             effect++;
-            elem++;
+            jntSphElem++;
         }
 
         if (this->collider.base.atFlags & AT_HIT) {
diff --git a/src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c b/src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c
index 708923c83b..4c7f971e79 100644
--- a/src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c
+++ b/src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c
@@ -1217,11 +1217,11 @@ void EnMushi2_Update(Actor* thisx, PlayState* play) {
                 }
 
                 if (phi_v0) {
-                    ColliderJntSphElement* element = &this->collider.elements[0];
+                    ColliderJntSphElement* jntSphElem = &this->collider.elements[0];
 
-                    element->dim.worldSphere.center.x = this->actor.world.pos.x;
-                    element->dim.worldSphere.center.y = this->actor.world.pos.y;
-                    element->dim.worldSphere.center.z = this->actor.world.pos.z;
+                    jntSphElem->dim.worldSphere.center.x = this->actor.world.pos.x;
+                    jntSphElem->dim.worldSphere.center.y = this->actor.world.pos.y;
+                    jntSphElem->dim.worldSphere.center.z = this->actor.world.pos.z;
                     CollisionCheck_SetOC(play, &play->colChkCtx, &this->collider.base);
                 }
             }
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 cdbedffcbf..9bed83f21c 100644
--- a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
+++ b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
@@ -232,7 +232,7 @@ u8 EnPametfrog_Vec3fNormalize(Vec3f* vec) {
 void EnPametfrog_Freeze(EnPametfrog* this) {
     this->drawDmgEffType = ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX;
     this->collider.base.colType = COLTYPE_HIT3;
-    this->collider.elements->info.elemType = ELEMTYPE_UNK0;
+    this->collider.elements[0].base.elemType = ELEMTYPE_UNK0;
     this->drawDmgEffScale = 0.75f;
     this->drawDmgEffFrozenSteamScale = 1.125f;
     this->drawDmgEffAlpha = 1.0f;
@@ -243,7 +243,7 @@ void EnPametfrog_Thaw(EnPametfrog* this, PlayState* play) {
     if (this->drawDmgEffType == ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX) {
         this->drawDmgEffType = ACTOR_DRAW_DMGEFF_FIRE;
         this->collider.base.colType = COLTYPE_HIT6;
-        this->collider.elements->info.elemType = ELEMTYPE_UNK1;
+        this->collider.elements[0].base.elemType = ELEMTYPE_UNK1;
         this->drawDmgEffAlpha = 0.0f;
         Actor_SpawnIceEffects(play, &this->actor, this->bodyPartsPos, GEKKO_BODYPART_MAX, 2, 0.3f, 0.2f);
     }
@@ -393,8 +393,8 @@ void EnPametfrog_ApplyMagicArrowEffects(EnPametfrog* this, PlayState* play) {
         this->drawDmgEffType = ACTOR_DRAW_DMGEFF_LIGHT_ORBS;
         this->drawDmgEffScale = 0.75f;
         this->drawDmgEffAlpha = 3.0f;
-        Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->collider.elements[0].info.bumper.hitPos.x,
-                    this->collider.elements[0].info.bumper.hitPos.y, this->collider.elements[0].info.bumper.hitPos.z, 0,
+        Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, this->collider.elements[0].base.bumper.hitPos.x,
+                    this->collider.elements[0].base.bumper.hitPos.y, this->collider.elements[0].base.bumper.hitPos.z, 0,
                     0, 0, CLEAR_TAG_PARAMS(CLEAR_TAG_LARGE_LIGHT_RAYS));
     } else if (this->actor.colChkInfo.damageEffect == GEKKO_DMGEFF_ICE) {
         EnPametfrog_Freeze(this);
@@ -1273,7 +1273,7 @@ void EnPametfrog_ApplyDamageEffect(EnPametfrog* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
         if ((this->drawDmgEffType != ACTOR_DRAW_DMGEFF_FROZEN_NO_SFX) ||
-            !(this->collider.elements->info.acHitElem->toucher.dmgFlags & 0xDB0B3)) {
+            !(this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0xDB0B3)) {
             if (this->actor.params == GEKKO_PRE_SNAPPER) {
                 if (Actor_ApplyDamage(&this->actor) == 0) {
                     Audio_RestorePrevBgm();
@@ -1301,9 +1301,9 @@ void EnPametfrog_ApplyDamageEffect(EnPametfrog* this, PlayState* play) {
                         this->drawDmgEffScale = 0.75f;
                         this->drawDmgEffAlpha = 4.0f;
                         Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG,
-                                    this->collider.elements[0].info.bumper.hitPos.x,
-                                    this->collider.elements[0].info.bumper.hitPos.y,
-                                    this->collider.elements[0].info.bumper.hitPos.z, 0, 0, 0,
+                                    this->collider.elements[0].base.bumper.hitPos.x,
+                                    this->collider.elements[0].base.bumper.hitPos.y,
+                                    this->collider.elements[0].base.bumper.hitPos.z, 0, 0, 0,
                                     CLEAR_TAG_PARAMS(CLEAR_TAG_LARGE_LIGHT_RAYS));
                     }
                     EnPametfrog_SetupDamage(this);
diff --git a/src/overlays/actors/ovl_En_Pp/z_en_pp.c b/src/overlays/actors/ovl_En_Pp/z_en_pp.c
index 2a3eeb5c17..9d8b90e38d 100644
--- a/src/overlays/actors/ovl_En_Pp/z_en_pp.c
+++ b/src/overlays/actors/ovl_En_Pp/z_en_pp.c
@@ -248,9 +248,9 @@ void EnPp_Init(Actor* thisx, PlayState* play) {
         this->bodyCollider.elements[0].dim.scale = 1.0f;
         if (EN_PP_GET_TYPE(&this->actor) > EN_PP_TYPE_MASKED) {
             this->actor.hintId = TATL_HINT_ID_HIPLOOP;
-            this->maskColliderElements[0].info.toucherFlags &= ~TOUCH_ON;
-            this->maskColliderElements[0].info.bumperFlags &= ~BUMP_ON;
-            this->maskColliderElements[0].info.ocElemFlags &= ~OCELEM_ON;
+            this->maskColliderElements[0].base.toucherFlags &= ~TOUCH_ON;
+            this->maskColliderElements[0].base.bumperFlags &= ~BUMP_ON;
+            this->maskColliderElements[0].base.ocElemFlags &= ~OCELEM_ON;
             this->maskCollider.base.colType = COLTYPE_HIT2;
             this->maskCollider.elements[0].dim.modelSphere.radius = 42;
             this->maskCollider.elements[0].dim.scale = 1.0f;
@@ -270,8 +270,8 @@ void EnPp_Init(Actor* thisx, PlayState* play) {
             this->bodyCollider.elements[0].dim.scale = 1.0f;
             this->bodyCollider.elements[0].dim.modelSphere.center.x = 400;
             this->bodyCollider.elements[0].dim.modelSphere.center.y = -400;
-            this->bodyColliderElements[0].info.bumperFlags |= BUMP_HOOKABLE;
-            this->maskCollider.elements[0].info.toucher.damage = 0x10;
+            this->bodyColliderElements[0].base.bumperFlags |= BUMP_HOOKABLE;
+            this->maskCollider.elements[0].base.toucher.damage = 0x10;
         }
 
         Collider_InitQuad(play, &this->hornCollider);
@@ -1257,7 +1257,7 @@ void EnPp_UpdateDamage(EnPp* this, PlayState* play) {
     }
 
     if ((EN_PP_GET_TYPE(&this->actor) == EN_PP_TYPE_MASKED) && (this->action < EN_PP_ACTION_MASK_DETACH)) {
-        if (this->maskCollider.elements[0].info.bumperFlags & BUMP_HIT) {
+        if (this->maskCollider.elements[0].base.bumperFlags & BUMP_HIT) {
             if (yawDiff < (BREG(2) + 0x4A9C)) {
                 if (this->actor.colChkInfo.damageEffect == EN_PP_DMGEFF_HOOKSHOT) {
                     EnPp_Mask_SetupDetach(this, play);
@@ -1269,12 +1269,12 @@ void EnPp_UpdateDamage(EnPp* this, PlayState* play) {
             } else {
                 attackBouncedOffMask = true;
             }
-        } else if (this->maskCollider.elements[0].info.bumperFlags & BUMP_HIT) {
+        } else if (this->maskCollider.elements[0].base.bumperFlags & BUMP_HIT) {
             attackBouncedOffMask = true;
         }
     }
 
-    if (this->bodyCollider.elements[0].info.bumperFlags & BUMP_HIT) {
+    if (this->bodyCollider.elements[0].base.bumperFlags & BUMP_HIT) {
         if (EN_PP_GET_TYPE(&this->actor) != EN_PP_TYPE_MASKED) {
             if ((this->action < EN_PP_ACTION_DAMAGED) && (this->action != EN_PP_ACTION_JUMP)) {
                 if (this->actor.colChkInfo.damageEffect == EN_PP_DMGEFF_HOOKSHOT) {
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 db5e324df8..0356473ab9 100644
--- a/src/overlays/actors/ovl_En_Ruppecrow/z_en_ruppecrow.c
+++ b/src/overlays/actors/ovl_En_Ruppecrow/z_en_ruppecrow.c
@@ -111,10 +111,10 @@ static InitChainEntry sInitChain[] = {
 s32 EnRuppecrow_UpdateCollision(EnRuppecrow* this, PlayState* play) {
     s32 pad;
 
-    this->collider.elements->dim.worldSphere.center.x = this->actor.world.pos.x;
-    this->collider.elements->dim.worldSphere.center.y =
-        sJntSphInit.elements->dim.modelSphere.center.y + this->actor.world.pos.y;
-    this->collider.elements->dim.worldSphere.center.z = this->actor.world.pos.z;
+    this->collider.elements[0].dim.worldSphere.center.x = this->actor.world.pos.x;
+    this->collider.elements[0].dim.worldSphere.center.y =
+        sJntSphInit.elements[0].dim.modelSphere.center.y + this->actor.world.pos.y;
+    this->collider.elements[0].dim.worldSphere.center.z = this->actor.world.pos.z;
 
     CollisionCheck_SetAC(play, &play->colChkCtx, &this->collider.base);
     Actor_UpdateBgCheckInfo(play, &this->actor, 12.0f, 25.0f, 50.0f,
@@ -476,7 +476,7 @@ void EnRuppecrow_HandleDeath(EnRuppecrow* this) {
 void EnRuppecrow_UpdateDamage(EnRuppecrow* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.elements->info);
+        Actor_SetDropFlag(&this->actor, &this->collider.elements[0].base);
 
         if (this->actor.colChkInfo.damageEffect != 0x1) {
             this->actor.colChkInfo.health = 0;
@@ -633,7 +633,7 @@ void EnRuppecrow_Init(Actor* thisx, PlayState* play2) {
 
     Collider_InitJntSph(play, &this->collider);
     Collider_InitAndSetJntSph(play, &this->collider, &this->actor, &sJntSphInit, this->colliderElements);
-    this->collider.elements->dim.worldSphere.radius = sJntSphInit.elements->dim.modelSphere.radius;
+    this->collider.elements[0].dim.worldSphere.radius = sJntSphInit.elements[0].dim.modelSphere.radius;
     CollisionCheck_SetInfo(&this->actor.colChkInfo, &sDamageTable, &sColChkInfoInit);
 
     Actor_SetScale(&this->actor, 0.01f);
diff --git a/src/overlays/actors/ovl_En_Scopecrow/z_en_scopecrow.c b/src/overlays/actors/ovl_En_Scopecrow/z_en_scopecrow.c
index 6f7d5b1f5c..0a257edc81 100644
--- a/src/overlays/actors/ovl_En_Scopecrow/z_en_scopecrow.c
+++ b/src/overlays/actors/ovl_En_Scopecrow/z_en_scopecrow.c
@@ -58,10 +58,10 @@ static ColliderJntSphInit sJntSphInit = {
 };
 
 void func_80BCD000(EnScopecrow* this, PlayState* play) {
-    this->collider.elements->dim.worldSphere.center.x = this->actor.world.pos.x;
-    this->collider.elements->dim.worldSphere.center.y =
+    this->collider.elements[0].dim.worldSphere.center.x = this->actor.world.pos.x;
+    this->collider.elements[0].dim.worldSphere.center.y =
         sJntSphInit.elements[0].dim.modelSphere.center.y + this->actor.world.pos.y;
-    this->collider.elements->dim.worldSphere.center.z = this->actor.world.pos.z;
+    this->collider.elements[0].dim.worldSphere.center.z = this->actor.world.pos.z;
 
     CollisionCheck_SetAC(play, &play->colChkCtx, &this->collider.base);
 }
@@ -316,7 +316,7 @@ void EnScopecrow_Init(Actor* thisx, PlayState* play) {
 
         Collider_InitJntSph(play, &this->collider);
         Collider_InitAndSetJntSph(play, &this->collider, &this->actor, &sJntSphInit, this->colliderElements);
-        this->collider.elements->dim.worldSphere.radius = sJntSphInit.elements[0].dim.modelSphere.radius;
+        this->collider.elements[0].dim.worldSphere.radius = sJntSphInit.elements[0].dim.modelSphere.radius;
 
         Actor_SetScale(&this->actor, 0.03f);
         this->path = SubS_GetPathByIndex(play, ENSCOPECROW_GET_PATH_INDEX(&this->actor), ENSCOPECROW_PATH_INDEX_NONE);
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 4a1ca7e1e3..993ab196f8 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
@@ -181,7 +181,7 @@ void EnSyatekiWf_Init(Actor* thisx, PlayState* play) {
     Collider_SetCylinder(play, &this->tailCollider, &this->actor, &sTailCylinderInit);
     Collider_InitJntSph(play, &this->headCollider);
     Collider_SetJntSph(play, &this->headCollider, &this->actor, &sJntSphInit, this->headColliderElements);
-    this->headCollider.elements->dim.worldSphere.radius = sJntSphInit.elements[0].dim.modelSphere.radius;
+    this->headCollider.elements[0].dim.worldSphere.radius = sJntSphInit.elements[0].dim.modelSphere.radius;
 
     SkelAnime_InitFlex(play, &this->skelAnime, &gWolfosNormalSkel, &gWolfosWaitAnim, this->jointTable, this->morphTable,
                        WOLFOS_NORMAL_LIMB_MAX);
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 3251a53fc8..683271b954 100644
--- a/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c
+++ b/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c
@@ -928,18 +928,18 @@ void func_80C127F4(EnThiefbird* this, PlayState* play) {
 }
 
 void func_80C12B1C(EnThiefbird* this, PlayState* play) {
-    ColliderJntSphElement* sph;
+    ColliderJntSphElement* jntSphElem;
     s32 i;
 
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
         this->collider.base.atFlags &= ~AT_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.elements->info);
+        Actor_SetDropFlag(&this->actor, &this->collider.elements[0].base);
         func_80C114C0(this, play);
         this->unk_194 = 0;
 
         for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++) {
-            if (this->collider.elements[i].info.bumperFlags & BUMP_HIT) {
+            if (this->collider.elements[i].base.bumperFlags & BUMP_HIT) {
                 break;
             }
         }
@@ -951,9 +951,9 @@ void func_80C12B1C(EnThiefbird* this, PlayState* play) {
             this->drawDmgEffScale = 0.5f;
             this->drawDmgEffAlpha = 4.0f;
             if (i != ARRAY_COUNT(this->colliderElements)) {
-                sph = &this->collider.elements[i];
-                Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, sph->info.bumper.hitPos.x,
-                            sph->info.bumper.hitPos.y, sph->info.bumper.hitPos.z, 0, 0, 0,
+                jntSphElem = &this->collider.elements[i];
+                Actor_Spawn(&play->actorCtx, play, ACTOR_EN_CLEAR_TAG, jntSphElem->base.bumper.hitPos.x,
+                            jntSphElem->base.bumper.hitPos.y, jntSphElem->base.bumper.hitPos.z, 0, 0, 0,
                             CLEAR_TAG_PARAMS(CLEAR_TAG_LARGE_LIGHT_RAYS));
             }
         } else if (this->actor.colChkInfo.damageEffect == 2) {
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 e5abb84250..b05db90d3c 100644
--- a/src/overlays/actors/ovl_En_Vm/z_en_vm.c
+++ b/src/overlays/actors/ovl_En_Vm/z_en_vm.c
@@ -411,7 +411,7 @@ void func_808CCDE4(EnVm* this, PlayState* play) {
         this->colliderJntSph.base.acFlags &= ~AC_HIT;
 
         for (i = 0; i < ARRAY_COUNT(this->colliderJntSphElements); i++) {
-            if (this->colliderJntSph.elements[i].info.bumperFlags & BUMP_HIT) {
+            if (this->colliderJntSph.elements[i].base.bumperFlags & BUMP_HIT) {
                 break;
             }
         }
diff --git a/src/overlays/actors/ovl_En_Wdhand/z_en_wdhand.c b/src/overlays/actors/ovl_En_Wdhand/z_en_wdhand.c
index 355f9373de..28d15e81fc 100644
--- a/src/overlays/actors/ovl_En_Wdhand/z_en_wdhand.c
+++ b/src/overlays/actors/ovl_En_Wdhand/z_en_wdhand.c
@@ -209,10 +209,10 @@ void EnWdhand_Init(Actor* thisx, PlayState* play) {
     Collider_InitAndSetJntSph(play, &this->collider, &this->actor, &sJntSphInit, this->colliderElements);
 
     for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++) {
-        ColliderJntSphElement* elem = &this->collider.elements[i];
+        ColliderJntSphElement* jntSphElem = &this->collider.elements[i];
 
-        elem->dim.worldSphere.radius = elem->dim.modelSphere.radius;
-        EnWdhand_Vec3fToVec3s(&elem->dim.worldSphere.center, &this->actor.world.pos);
+        jntSphElem->dim.worldSphere.radius = jntSphElem->dim.modelSphere.radius;
+        EnWdhand_Vec3fToVec3s(&jntSphElem->dim.worldSphere.center, &this->actor.world.pos);
     }
 
     for (i = 0; i < EN_WDHAND_NUM_SEGMENTS; i++) {
@@ -601,7 +601,7 @@ void EnWdhand_SetupDie(EnWdhand* this) {
 
     // Finds the particular collider that was hit
     for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++) {
-        if (this->collider.elements[i].info.bumperFlags & BUMP_HIT) {
+        if (this->collider.elements[i].base.bumperFlags & BUMP_HIT) {
             break;
         }
     }
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 ef0e0360f2..ece432b239 100644
--- a/src/overlays/actors/ovl_En_Wf/z_en_wf.c
+++ b/src/overlays/actors/ovl_En_Wf/z_en_wf.c
@@ -322,8 +322,8 @@ void EnWf_Init(Actor* thisx, PlayState* play) {
                            this->morphTable, WOLFOS_NORMAL_LIMB_MAX);
         this->actor.hintId = TATL_HINT_ID_WOLFOS;
         CollisionCheck_SetInfo(&this->actor.colChkInfo, &sDamageTable2, &sColChkInfoInit);
-        this->collider1.elements[0].info.toucher.damage = 8;
-        this->collider1.elements[1].info.toucher.damage = 8;
+        this->collider1.elements[0].base.toucher.damage = 8;
+        this->collider1.elements[1].base.toucher.damage = 8;
         this->actor.colChkInfo.health = 6;
     } else {
         SkelAnime_InitFlex(play, &this->skelAnime, &gWolfosWhiteSkel, &gWolfosWaitAnim, this->jointTable,
diff --git a/src/overlays/actors/ovl_En_Wiz/z_en_wiz.c b/src/overlays/actors/ovl_En_Wiz/z_en_wiz.c
index 6ed18aef5b..ded9d4179b 100644
--- a/src/overlays/actors/ovl_En_Wiz/z_en_wiz.c
+++ b/src/overlays/actors/ovl_En_Wiz/z_en_wiz.c
@@ -762,7 +762,7 @@ void EnWiz_Appear(EnWiz* this, PlayState* play) {
             } else {
                 this->action = EN_WIZ_ACTION_RUN_IN_CIRCLES;
                 this->actor.flags &= ~ACTOR_FLAG_CANT_LOCK_ON;
-                this->ghostColliders.elements[0].info.bumper.dmgFlags = 0x1013A22;
+                this->ghostColliders.elements[0].base.bumper.dmgFlags = 0x1013A22;
                 Math_Vec3f_Copy(&this->staffTargetFlameScale, &staffTargetFlameScale);
                 this->targetPlatformLightAlpha = 0;
 
@@ -1049,7 +1049,7 @@ void EnWiz_Disappear(EnWiz* this, PlayState* play) {
         if (this->introCutsceneState != EN_WIZ_INTRO_CS_DISAPPEAR) {
             this->alpha = 0;
             if (this->fightState == EN_WIZ_FIGHT_STATE_FIRST_PHASE) {
-                this->ghostColliders.elements[0].info.bumper.dmgFlags = 0x1000202;
+                this->ghostColliders.elements[0].base.bumper.dmgFlags = 0x1000202;
             }
 
             this->actor.flags |= ACTOR_FLAG_TARGETABLE;
@@ -1281,7 +1281,7 @@ void EnWiz_UpdateDamage(EnWiz* this, PlayState* play) {
             // in the final game, since EnWiz_Init effectively disables them), then the below code will
             // "destroy" the ghost by turning into a cloud of smoke.
             if ((R_TRANS_FADE_FLASH_ALPHA_STEP != 0) ||
-                (this->ghostColliders.elements[i + 1].info.bumperFlags & BUMP_HIT)) {
+                (this->ghostColliders.elements[i + 1].base.bumperFlags & BUMP_HIT)) {
                 //! @bug: If a single ghost is destroyed, then changing the fight state here will cause
                 //! strange behavior; the ghosts will stand still and pretend to attack the player like
                 //! the real Wizrobe. Since Deku Nuts destroy all ghosts at once, and since the ghost
diff --git a/src/overlays/actors/ovl_Mir_Ray/z_mir_ray.c b/src/overlays/actors/ovl_Mir_Ray/z_mir_ray.c
index 4df300499b..8173fb2b27 100644
--- a/src/overlays/actors/ovl_Mir_Ray/z_mir_ray.c
+++ b/src/overlays/actors/ovl_Mir_Ray/z_mir_ray.c
@@ -247,11 +247,11 @@ void MirRay_SetupCollider(MirRay* this) {
     f32 y = (this->poolPt.y - this->sourcePt.y) * dataEntry->unk_10;
     f32 z = (this->poolPt.z - this->sourcePt.z) * dataEntry->unk_10;
 
-    this->collider1.elements[0].dim.worldSphere.center.x = this->sourcePt.x + x;
-    this->collider1.elements[0].dim.worldSphere.center.y = this->sourcePt.y + y;
-    this->collider1.elements[0].dim.worldSphere.center.z = this->sourcePt.z + z;
+    this->collider1.elements->dim.worldSphere.center.x = this->sourcePt.x + x;
+    this->collider1.elements->dim.worldSphere.center.y = this->sourcePt.y + y;
+    this->collider1.elements->dim.worldSphere.center.z = this->sourcePt.z + z;
 
-    this->collider1.elements[0].dim.worldSphere.radius = dataEntry->unk_14 * this->collider1.elements->dim.scale;
+    this->collider1.elements->dim.worldSphere.radius = dataEntry->unk_14 * this->collider1.elements->dim.scale;
 }
 
 // Set up a light point between source point and reflection point. Reflection point is the pool point (for windows) or
diff --git a/src/overlays/actors/ovl_Obj_Comb/z_obj_comb.c b/src/overlays/actors/ovl_Obj_Comb/z_obj_comb.c
index fba6519a58..dfe5b022f6 100644
--- a/src/overlays/actors/ovl_Obj_Comb/z_obj_comb.c
+++ b/src/overlays/actors/ovl_Obj_Comb/z_obj_comb.c
@@ -380,12 +380,12 @@ void func_8098DC60(ObjComb* this, PlayState* play) {
     }
 
     if (this->unk_1B3) {
-        if (this->collider.elements->info.acHitElem->toucher.dmgFlags & 0x0182C29C) {
+        if (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x0182C29C) {
             func_8098CEAC(this, play);
             func_8098DA74(this, play);
             Actor_Kill(&this->actor);
         } else {
-            s32 dmgFlags = this->collider.elements->info.acHitElem->toucher.dmgFlags;
+            s32 dmgFlags = this->collider.elements[0].base.acHitElem->toucher.dmgFlags;
 
             if (dmgFlags & 0x13820) {
                 this->unk_1A8 = 0xDAC;
diff --git a/src/overlays/actors/ovl_Obj_Flowerpot/z_obj_flowerpot.c b/src/overlays/actors/ovl_Obj_Flowerpot/z_obj_flowerpot.c
index 50dde16845..f6d199b0d8 100644
--- a/src/overlays/actors/ovl_Obj_Flowerpot/z_obj_flowerpot.c
+++ b/src/overlays/actors/ovl_Obj_Flowerpot/z_obj_flowerpot.c
@@ -465,8 +465,8 @@ void func_80A1C838(ObjFlowerpot* this, PlayState* play) {
         func_80A1BD80(this, play);
         func_80A1B994(this, play);
         Actor_Kill(&this->actor);
-    } else if ((this->collider.elements[0].info.bumperFlags & BUMP_HIT) &&
-               (this->collider.elements[0].info.acHitElem->toucher.dmgFlags & 0x058BFFBC)) {
+    } else if ((this->collider.elements[0].base.bumperFlags & BUMP_HIT) &&
+               (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x058BFFBC)) {
         if (!(this->unk_1EA & 2)) {
             func_80A1B914(this, play);
             func_80A1C0FC(this, play);
@@ -477,10 +477,10 @@ void func_80A1C838(ObjFlowerpot* this, PlayState* play) {
         func_80A1B994(this, play);
         Actor_Kill(&this->actor);
     } else {
-        if (this->collider.elements[1].info.bumperFlags & BUMP_HIT) {
+        if (this->collider.elements[1].base.bumperFlags & BUMP_HIT) {
             if (!(this->unk_1EA & 2)) {
                 this->unk_1EA |= 2;
-                this->collider.elements[1].info.bumperFlags &= ~BUMP_ON;
+                this->collider.elements[1].base.bumperFlags &= ~BUMP_ON;
                 func_80A1C0FC(this, play);
                 func_80A1B914(this, play);
                 func_80A1B9CC(this, play);
@@ -589,10 +589,10 @@ void func_80A1CD10(ObjFlowerpot* this) {
 
 void func_80A1CEF4(ObjFlowerpot* this, PlayState* play) {
     Actor* thisx = &this->actor;
-    s32 sp28 = this->collider.elements[0].info.toucherFlags & TOUCH_HIT;
+    s32 sp28 = this->collider.elements[0].base.toucherFlags & TOUCH_HIT;
 
     if (sp28) {
-        this->collider.elements[0].info.toucherFlags &= ~TOUCH_ON;
+        this->collider.elements[0].base.toucherFlags &= ~TOUCH_ON;
     }
 
     if (this->unk_1E8 > 0) {
diff --git a/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c b/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
index c84bb53f47..bdd3b6fa83 100644
--- a/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
+++ b/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
@@ -328,7 +328,7 @@ void ObjLightswitch_Update(Actor* thisx, PlayState* play) {
 
     if (this->collider.base.acFlags & AC_HIT) {
         // dmgFlags enum doesn't exist yet, 0x2000 is light arrows
-        if ((this->collider.elements->info.acHitElem->toucher.dmgFlags & 0x2000) != 0) {
+        if ((this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x2000) != 0) {
             this->hitState = 10;
         } else if (LIGHTSWITCH_GET_TYPE(&this->actor) == LIGHTSWITCH_TYPE_FLIP) {
             if (this->hitState == 0) {
diff --git a/src/overlays/actors/ovl_Obj_Mine/z_obj_mine.c b/src/overlays/actors/ovl_Obj_Mine/z_obj_mine.c
index 8faa0b05c5..da8fcc943d 100644
--- a/src/overlays/actors/ovl_Obj_Mine/z_obj_mine.c
+++ b/src/overlays/actors/ovl_Obj_Mine/z_obj_mine.c
@@ -182,12 +182,12 @@ void ObjMine_Air_CheckAC(ObjMine* this, s16* hitAngle, s16* torqueAngle) {
     yawToAttack = Math_Vec3f_Yaw(&attackActor->world.pos, &centerPos);
 
     // dmgFlag check is (DMG_DEKU_BUBBLE | DMG_FIRE_ARROW | DMG_ICE_ARROW | DMG_FIRE_ARROW | DMG_NORMAL_ARROW)
-    if (this->collider.elements[0].info.acHitElem->toucher.dmgFlags & 0x13820) {
+    if (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x13820) {
         *hitAngle = attackActor->shape.rot.y;
         *torqueAngle = attackActor->shape.rot.y - yawToAttack;
     } else {
         Vec3f hitPos;
-        Vec3s* hitPos3s = &this->collider.elements[0].info.bumper.hitPos;
+        Vec3s* hitPos3s = &this->collider.elements[0].base.bumper.hitPos;
 
         Math_Vec3s_ToVec3f(&hitPos, hitPos3s);
         *hitAngle = Actor_WorldYawTowardActor(attackActor, &this->actor);
@@ -199,7 +199,7 @@ void ObjMine_Water_CheckAC(ObjMine* this, Vec3f* knockbackDir) {
     Actor* attackActor = this->collider.base.ac;
 
     // dmgFlag check is (DMG_DEKU_BUBBLE | DMG_LIGHT_ARROW | DMG_ICE_ARROW | DMG_FIRE_ARROW | DMG_NORMAL_ARROW)
-    if (this->collider.elements[0].info.acHitElem->toucher.dmgFlags & 0x13820) {
+    if (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x13820) {
         Matrix_Push();
         Matrix_RotateYS(attackActor->shape.rot.y, MTXMODE_NEW);
         Matrix_RotateXS(attackActor->shape.rot.x, MTXMODE_APPLY);
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 d27fc33a7e..972b9a6742 100644
--- a/src/overlays/actors/ovl_Obj_Snowball/z_obj_snowball.c
+++ b/src/overlays/actors/ovl_Obj_Snowball/z_obj_snowball.c
@@ -139,7 +139,7 @@ void func_80B02EE4(ObjSnowball* this, PlayState* play) {
     Vec3f spAC;
     Vec3f spA0;
     Vec3f sp94;
-    Vec3s* hitPos = &this->collider.elements->info.bumper.hitPos;
+    Vec3s* hitPos = &this->collider.elements[0].base.bumper.hitPos;
     s32 i;
 
     for (i = 0; i < 4; i++) {
@@ -533,17 +533,17 @@ void func_80B04350(ObjSnowball* this, PlayState* play) {
     }
 
     if (flag && (this->unk_211 == 0) &&
-        (this->collider.elements->info.acHitElem->toucher.dmgFlags &
+        (this->collider.elements[0].base.acHitElem->toucher.dmgFlags &
          (0x80000000 | 0x4000 | 0x800 | 0x400 | 0x100 | 0x8))) {
         this->actor.flags |= ACTOR_FLAG_10;
         if (this->actor.home.rot.y == 1) {
             this->actor.flags &= ~(ACTOR_FLAG_TARGETABLE | ACTOR_FLAG_FRIENDLY);
         }
 
-        if (this->collider.elements->info.acHitElem->toucher.dmgFlags & 0x4000) {
+        if (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x4000) {
             this->unk_20A = 1;
         } else {
-            if (this->collider.elements->info.acHitElem->toucher.dmgFlags & 0x800) {
+            if (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x800) {
                 this->unk_210 = 1;
             }
             this->unk_20A = 0;
@@ -563,10 +563,10 @@ void func_80B04350(ObjSnowball* this, PlayState* play) {
     }
 
     if (flag &&
-        !(this->collider.elements->info.acHitElem->toucher.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20))) {
+        !(this->collider.elements[0].base.acHitElem->toucher.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20))) {
         if (this->unk_209 <= 0) {
             func_80B02EE4(this, play);
-            if (this->collider.elements->info.acHitElem->toucher.dmgFlags & 0x1000000) {
+            if (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x1000000) {
                 this->unk_209 = 25;
             } else {
                 this->unk_209 = 10;
diff --git a/src/overlays/actors/ovl_Obj_Snowball2/z_obj_snowball2.c b/src/overlays/actors/ovl_Obj_Snowball2/z_obj_snowball2.c
index 27f5656f3d..c7356129e9 100644
--- a/src/overlays/actors/ovl_Obj_Snowball2/z_obj_snowball2.c
+++ b/src/overlays/actors/ovl_Obj_Snowball2/z_obj_snowball2.c
@@ -273,8 +273,8 @@ void func_80B39908(ObjSnowball2* this, PlayState* play) {
     Vec3f sp94;
     s32 i;
 
-    if (this->collider.elements[0].info.bumperFlags & BUMP_HIT) {
-        Vec3s* hitPos = &this->collider.elements[0].info.bumper.hitPos;
+    if (this->collider.elements[0].base.bumperFlags & BUMP_HIT) {
+        Vec3s* hitPos = &this->collider.elements[0].base.bumper.hitPos;
 
         for (i = 0; i < 4; i++) {
             sp94.x = ((Rand_ZeroOne() * 14.0f) - 7.0f) + hitPos->x;
@@ -361,14 +361,14 @@ void func_80B39C9C(ObjSnowball2* this, PlayState* play) {
     } else if ((this->actor.bgCheckFlags & BGCHECKFLAG_WATER) &&
                ((this->actor.shape.yOffset * this->actor.scale.y) < this->actor.depthInWater)) {
         func_80B3A498(this);
-    } else if (sp38 && (this->collider.elements->info.acHitElem->toucher.dmgFlags & 0x0583FFBC)) {
+    } else if (sp38 && (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 0x0583FFBC)) {
         func_80B38E88(this, play);
         func_80B39108(this, play);
         func_80B39B5C(this, play);
         Actor_Kill(&this->actor);
         return;
     } else {
-        if (sp38 && (this->collider.elements->info.acHitElem->toucher.dmgFlags & 2)) {
+        if (sp38 && (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & 2)) {
             func_80B39908(this, play);
         }