diff --git a/include/functions.h b/include/functions.h
index b7e90446e0..7e9cc99ac5 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -494,7 +494,7 @@ void func_8003555C(PlayState* play, Vec3f* pos, Vec3f* velocity, Vec3f* accel);
 void func_800355B8(PlayState* play, Vec3f* pos);
 u8 func_800355E4(PlayState* play, Collider* collider);
 u8 Actor_ApplyDamage(Actor* actor);
-void Actor_SetDropFlag(Actor* actor, ColliderInfo* colInfo, s32 freezeFlag);
+void Actor_SetDropFlag(Actor* actor, ColliderElement* elem, s32 freezeFlag);
 void Actor_SetDropFlagJntSph(Actor* actor, ColliderJntSph* jntSph, s32 freezeFlag);
 void func_80035844(Vec3f* arg0, Vec3f* arg1, Vec3s* arg2, s32 arg3);
 Actor* func_800358DC(Actor* actor, Vec3f* spawnPos, Vec3s* spawnRot, f32* arg3, s32 timer, s16* unused,
@@ -662,44 +662,43 @@ DamageTable* DamageTable_Get(s32 index);
 void DamageTable_Clear(DamageTable* table);
 void Collider_DrawRedPoly(GraphicsContext* gfxCtx, Vec3f* vA, Vec3f* vB, Vec3f* vC);
 void Collider_DrawPoly(GraphicsContext* gfxCtx, Vec3f* vA, Vec3f* vB, Vec3f* vC, u8 r, u8 g, u8 b);
-s32 Collider_InitJntSph(PlayState* play, ColliderJntSph* collider);
-s32 Collider_FreeJntSph(PlayState* play, ColliderJntSph* collider);
-s32 Collider_DestroyJntSph(PlayState* play, ColliderJntSph* collider);
+s32 Collider_InitJntSph(PlayState* play, ColliderJntSph* jntSph);
+s32 Collider_FreeJntSph(PlayState* play, ColliderJntSph* jntSph);
+s32 Collider_DestroyJntSph(PlayState* play, ColliderJntSph* jntSph);
 s32 Collider_SetJntSphToActor(PlayState* play, ColliderJntSph* dest, ColliderJntSphInitToActor* src);
 s32 Collider_SetJntSphAllocType1(PlayState* play, ColliderJntSph* dest, Actor* actor,
                                  ColliderJntSphInitType1* src);
 s32 Collider_SetJntSphAlloc(PlayState* play, ColliderJntSph* dest, Actor* actor, ColliderJntSphInit* src);
 s32 Collider_SetJntSph(PlayState* play, ColliderJntSph* dest, Actor* actor, ColliderJntSphInit* src,
-                       ColliderJntSphElement* elements);
-s32 Collider_ResetJntSphAT(PlayState* play, Collider* collider);
-s32 Collider_ResetJntSphAC(PlayState* play, Collider* collider);
-s32 Collider_ResetJntSphOC(PlayState* play, Collider* collider);
-s32 Collider_InitCylinder(PlayState* play, ColliderCylinder* collider);
-s32 Collider_DestroyCylinder(PlayState* play, ColliderCylinder* collider);
-s32 Collider_SetCylinderToActor(PlayState* play, ColliderCylinder* collider, ColliderCylinderInitToActor* src);
-s32 Collider_SetCylinderType1(PlayState* play, ColliderCylinder* collider, Actor* actor,
-                              ColliderCylinderInitType1* src);
-s32 Collider_SetCylinder(PlayState* play, ColliderCylinder* collider, Actor* actor, ColliderCylinderInit* src);
-s32 Collider_ResetCylinderAT(PlayState* play, Collider* collider);
-s32 Collider_ResetCylinderAC(PlayState* play, Collider* collider);
-s32 Collider_ResetCylinderOC(PlayState* play, Collider* collider);
+                       ColliderJntSphElement* jntSphElements);
+s32 Collider_ResetJntSphAT(PlayState* play, Collider* col);
+s32 Collider_ResetJntSphAC(PlayState* play, Collider* col);
+s32 Collider_ResetJntSphOC(PlayState* play, Collider* col);
+s32 Collider_InitCylinder(PlayState* play, ColliderCylinder* cyl);
+s32 Collider_DestroyCylinder(PlayState* play, ColliderCylinder* cyl);
+s32 Collider_SetCylinderToActor(PlayState* play, ColliderCylinder* dest, ColliderCylinderInitToActor* src);
+s32 Collider_SetCylinderType1(PlayState* play, ColliderCylinder* dest, Actor* actor, ColliderCylinderInitType1* src);
+s32 Collider_SetCylinder(PlayState* play, ColliderCylinder* dest, Actor* actor, ColliderCylinderInit* src);
+s32 Collider_ResetCylinderAT(PlayState* play, Collider* col);
+s32 Collider_ResetCylinderAC(PlayState* play, Collider* col);
+s32 Collider_ResetCylinderOC(PlayState* play, Collider* col);
 s32 Collider_InitTris(PlayState* play, ColliderTris* tris);
 s32 Collider_FreeTris(PlayState* play, ColliderTris* tris);
 s32 Collider_DestroyTris(PlayState* play, ColliderTris* tris);
 s32 Collider_SetTrisAllocType1(PlayState* play, ColliderTris* dest, Actor* actor, ColliderTrisInitType1* src);
 s32 Collider_SetTrisAlloc(PlayState* play, ColliderTris* dest, Actor* actor, ColliderTrisInit* src);
 s32 Collider_SetTris(PlayState* play, ColliderTris* dest, Actor* actor, ColliderTrisInit* src,
-                     ColliderTrisElement* elements);
-s32 Collider_ResetTrisAT(PlayState* play, Collider* collider);
-s32 Collider_ResetTrisAC(PlayState* play, Collider* collider);
-s32 Collider_ResetTrisOC(PlayState* play, Collider* collider);
-s32 Collider_InitQuad(PlayState* play, ColliderQuad* collider);
-s32 Collider_DestroyQuad(PlayState* play, ColliderQuad* collider);
-s32 Collider_SetQuadType1(PlayState* play, ColliderQuad* collider, Actor* actor, ColliderQuadInitType1* src);
-s32 Collider_SetQuad(PlayState* play, ColliderQuad* collider, Actor* actor, ColliderQuadInit* src);
-s32 Collider_ResetQuadAT(PlayState* play, Collider* collider);
-s32 Collider_ResetQuadAC(PlayState* play, Collider* collider);
-s32 Collider_ResetQuadOC(PlayState* play, Collider* collider);
+                     ColliderTrisElement* trisElements);
+s32 Collider_ResetTrisAT(PlayState* play, Collider* col);
+s32 Collider_ResetTrisAC(PlayState* play, Collider* col);
+s32 Collider_ResetTrisOC(PlayState* play, Collider* col);
+s32 Collider_InitQuad(PlayState* play, ColliderQuad* quad);
+s32 Collider_DestroyQuad(PlayState* play, ColliderQuad* quad);
+s32 Collider_SetQuadType1(PlayState* play, ColliderQuad* dest, Actor* actor, ColliderQuadInitType1* src);
+s32 Collider_SetQuad(PlayState* play, ColliderQuad* dest, Actor* actor, ColliderQuadInit* src);
+s32 Collider_ResetQuadAT(PlayState* play, Collider* col);
+s32 Collider_ResetQuadAC(PlayState* play, Collider* col);
+s32 Collider_ResetQuadOC(PlayState* play, Collider* col);
 s32 Collider_InitLine(PlayState* play, OcLine* line);
 s32 Collider_DestroyLine(PlayState* play, OcLine* line);
 s32 Collider_SetLinePoints(PlayState* play, OcLine* ocLine, Vec3f* a, Vec3f* b);
@@ -710,7 +709,7 @@ void CollisionCheck_DestroyContext(PlayState* play, CollisionCheckContext* colCh
 void CollisionCheck_ClearContext(PlayState* play, CollisionCheckContext* colChkCtx);
 void CollisionCheck_EnableSAC(PlayState* play, CollisionCheckContext* colChkCtx);
 void CollisionCheck_DisableSAC(PlayState* play, CollisionCheckContext* colChkCtx);
-void Collider_Draw(PlayState* play, Collider* collider);
+void Collider_Draw(PlayState* play, Collider* col);
 void CollisionCheck_DrawCollision(PlayState* play, CollisionCheckContext* colChkCtx);
 s32 CollisionCheck_SetAT(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider);
 s32 CollisionCheck_SetAT_SAC(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider, s32 index);
@@ -732,12 +731,12 @@ void CollisionCheck_Damage(PlayState* play, CollisionCheckContext* colChkCtx);
 s32 CollisionCheck_LineOCCheckAll(PlayState* play, CollisionCheckContext* colChkCtx, Vec3f* a, Vec3f* b);
 s32 CollisionCheck_LineOCCheck(PlayState* play, CollisionCheckContext* colChkCtx, Vec3f* a, Vec3f* b,
                                Actor** exclusions, s32 numExclusions);
-void Collider_UpdateCylinder(Actor* actor, ColliderCylinder* collider);
-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(PlayState* play, ColliderTris* collider, s32 index, ColliderTrisElementDimInit* src);
-void Collider_UpdateSpheres(s32 limb, ColliderJntSph* collider);
+void Collider_UpdateCylinder(Actor* actor, ColliderCylinder* cyl);
+void Collider_SetCylinderPosition(ColliderCylinder* cyl, Vec3s* pos);
+void Collider_SetQuadVertices(ColliderQuad* quad, Vec3f* a, Vec3f* b, Vec3f* c, Vec3f* d);
+void Collider_SetTrisVertices(ColliderTris* tris, s32 elemIndex, Vec3f* a, Vec3f* b, Vec3f* c);
+void Collider_SetTrisDim(PlayState* play, ColliderTris* tris, s32 elemIndex, ColliderTrisElementDimInit* src);
+void Collider_UpdateSpheres(s32 limb, ColliderJntSph* jntSph);
 void CollisionCheck_SpawnRedBlood(PlayState* play, Vec3f* v);
 void CollisionCheck_SpawnWaterDroplets(PlayState* play, Vec3f* v);
 void CollisionCheck_SpawnShieldParticles(PlayState* play, Vec3f* v);
diff --git a/include/z64.h b/include/z64.h
index f99078d985..09d205d5ee 100644
--- a/include/z64.h
+++ b/include/z64.h
@@ -273,6 +273,8 @@ typedef struct {
     /* 0x74 */ s16 unk_74[2]; // context-specific data used by the current scene draw config
 } RoomContext; // size = 0x78
 
+#define SAC_ENABLE (1 << 0)
+
 typedef struct {
     /* 0x000 */ s16 colATCount;
     /* 0x002 */ u16 sacFlags;
diff --git a/include/z64collision_check.h b/include/z64collision_check.h
index 3e4ae20f32..bf411201d9 100644
--- a/include/z64collision_check.h
+++ b/include/z64collision_check.h
@@ -8,226 +8,9 @@
 
 struct Actor;
 
-typedef struct {
-    /* 0x00 */ struct Actor* actor; // Attached actor
-    /* 0x04 */ struct Actor* at; // Actor attached to what it collided with as an AT collider.
-    /* 0x08 */ struct Actor* ac; // Actor attached to what it collided with as an AC collider.
-    /* 0x0C */ struct Actor* oc; // Actor attached to what it collided with as an OC collider.
-    /* 0x10 */ u8 atFlags; // Information flags for AT collisions.
-    /* 0x11 */ u8 acFlags; // Information flags for AC collisions.
-    /* 0x12 */ u8 ocFlags1; // Information flags for OC collisions.
-    /* 0x13 */ u8 ocFlags2;  // Flags related to which colliders it can OC collide with.
-    /* 0x14 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
-    /* 0x15 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
-} Collider; // size = 0x18
-
-typedef struct {
-    /* 0x00 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
-    /* 0x01 */ u8 atFlags; // Information flags for AT collisions.
-    /* 0x02 */ u8 acFlags; // Information flags for AC collisions.
-    /* 0x03 */ u8 ocFlags1; // Information flags for OC collisions.
-    /* 0x04 */ u8 ocFlags2; // Flags related to which colliders it can OC collide with.
-    /* 0x05 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
-} ColliderInit; // size = 0x06
-
-typedef struct {
-    /* 0x00 */ u8 colType; // Determines hitmarks and sound effects during AC collisions.
-    /* 0x01 */ u8 atFlags; // Information flags for AT collisions.
-    /* 0x02 */ u8 acFlags; // Information flags for AC collisions.
-    /* 0x03 */ u8 ocFlags1; // Information flags for OC collisions.
-    /* 0x04 */ u8 shape; // JntSph, Cylinder, Tris, or Quad
-} ColliderInitType1; // size = 0x05
-
-typedef struct {
-    /* 0x00 */ struct Actor* actor;
-    /* 0x04 */ u8 atFlags; // Information flags for AT collisions.
-    /* 0x05 */ u8 acFlags; // Information flags for AC collisions.
-    /* 0x06 */ u8 ocFlags1; // Information flags for OC collisions.
-    /* 0x07 */ u8 shape;   // JntSph, Cylinder, Tris, or Quad
-} ColliderInitToActor; // size = 0x08
-
-typedef struct {
-    /* 0x00 */ u32 dmgFlags; // Toucher damage type flags.
-    /* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
-    /* 0x05 */ u8 damage; // Damage or Stun Timer
-} ColliderTouch; // size = 0x08
-
-typedef struct {
-    /* 0x00 */ u32 dmgFlags;  // Bumper damage type flags.
-    /* 0x04 */ u8 effect;  // Damage Effect (Knockback, Fire, etc.)
-    /* 0x05 */ u8 defense; // Damage Resistance
-    /* 0x06 */ Vec3s hitPos; // Point of contact
-} ColliderBump; // size = 0x0C
-
-typedef struct {
-    /* 0x00 */ u32 dmgFlags; // Bumper exclusion mask
-    /* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
-    /* 0x05 */ u8 defense; // Damage Resistance
-} ColliderBumpInit; // size = 0x08
-
-typedef struct ColliderInfo {
-    /* 0x00 */ ColliderTouch toucher; // Damage properties when acting as an AT collider
-    /* 0x08 */ ColliderBump bumper; // Damage properties when acting as an AC collider
-    /* 0x14 */ u8 elemType; // Affects sfx reaction when attacked by Link and hookability. Full purpose unknown.
-    /* 0x15 */ u8 toucherFlags; // Information flags for AT collisions
-    /* 0x16 */ u8 bumperFlags; // Information flags for AC collisions
-    /* 0x17 */ u8 ocElemFlags; // Information flags for OC collisions
-    /* 0x18 */ Collider* atHit;                // object touching this element's AT collider
-    /* 0x1C */ Collider* acHit;                // object touching this element's AC collider
-    /* 0x20 */ struct ColliderInfo* atHitInfo; // element that hit the AT collider
-    /* 0x24 */ struct ColliderInfo* acHitInfo; // element that hit the AC collider
-} ColliderInfo; // size = 0x28
-
-typedef struct {
-    /* 0x00 */ u8 elemType; // Affects sfx reaction when attacked by Link and hookability. Full purpose unknown.
-    /* 0x04 */ ColliderTouch toucher; // Damage properties when acting as an AT collider
-    /* 0x0C */ ColliderBumpInit bumper; // Damage properties when acting as an AC collider
-    /* 0x14 */ u8 toucherFlags; // Information flags for AT collisions
-    /* 0x15 */ u8 bumperFlags;  // Information flags for AC collisions
-    /* 0x16 */ u8 ocElemFlags; // Information flags for OC collisions
-} ColliderInfoInit; // size = 0x18
-
-typedef struct {
-    /* 0x00 */ Sphere16 modelSphere; // model space sphere
-    /* 0x08 */ Sphere16 worldSphere; // world space sphere
-    /* 0x10 */ f32 scale;          // world space sphere = model * scale * 0.01
-    /* 0x14 */ u8 limb;           // attached limb
-} ColliderJntSphElementDim; // size = 0x18
-
-typedef struct {
-    /* 0x00 */ u8 limb; // attached limb
-    /* 0x02 */ Sphere16 modelSphere; // model space sphere
-    /* 0x0A */ s16 scale; // world space sphere = model * scale * 0.01
-} ColliderJntSphElementDimInit; // size = 0x0C
-
-typedef struct {
-    /* 0x00 */ ColliderInfo info;
-    /* 0x28 */ ColliderJntSphElementDim dim;
-} ColliderJntSphElement; // size = 0x40
-
-typedef struct {
-    /* 0x00 */ ColliderInfoInit info;
-    /* 0x18 */ ColliderJntSphElementDimInit dim;
-} ColliderJntSphElementInit; // size = 0x24
-
-typedef struct {
-    /* 0x00 */ Collider base;
-    /* 0x18 */ s32 count;
-    /* 0x1C */ ColliderJntSphElement* elements;
-} ColliderJntSph; // size = 0x20
-
-typedef struct {
-    /* 0x00 */ ColliderInit base;
-    /* 0x08 */ s32 count;
-    /* 0x0C */ ColliderJntSphElementInit* elements;
-} ColliderJntSphInit; // size = 0x10
-
-typedef struct {
-    /* 0x00 */ ColliderInitType1 base;
-    /* 0x08 */ s32 count;
-    /* 0x0C */ ColliderJntSphElementInit* elements;
-} ColliderJntSphInitType1; // size = 0x10
-
-typedef struct {
-    /* 0x00 */ ColliderInitToActor base;
-    /* 0x08 */ s32 count;
-    /* 0x0C */ ColliderJntSphElementInit* elements;
-} ColliderJntSphInitToActor; // size = 0x10
-
-typedef struct {
-    /* 0x00 */ Collider base;
-    /* 0x18 */ ColliderInfo info;
-    /* 0x40 */ Cylinder16 dim;
-} ColliderCylinder; // size = 0x4C
-
-typedef struct {
-    /* 0x00 */ ColliderInit base;
-    /* 0x08 */ ColliderInfoInit info;
-    /* 0x20 */ Cylinder16 dim;
-} ColliderCylinderInit; // size = 0x2C
-
-typedef struct {
-    /* 0x00 */ ColliderInitType1 base;
-    /* 0x08 */ ColliderInfoInit info;
-    /* 0x20 */ Cylinder16 dim;
-} ColliderCylinderInitType1; // size = 0x2C
-
-typedef struct {
-    /* 0x00 */ ColliderInitToActor base;
-    /* 0x08 */ ColliderInfoInit info;
-    /* 0x20 */ Cylinder16 dim;
-} ColliderCylinderInitToActor; // size = 0x2C
-
-typedef struct {
-    /* 0x00 */ Vec3f vtx[3];
-} ColliderTrisElementDimInit; // size = 0x24
-
-typedef struct {
-    /* 0x00 */ ColliderInfo info;
-    /* 0x28 */ TriNorm dim;
-} ColliderTrisElement; // size = 0x5C
-
-typedef struct {
-    /* 0x00 */ ColliderInfoInit info;
-    /* 0x18 */ ColliderTrisElementDimInit dim;
-} ColliderTrisElementInit; // size = 0x3C
-
-typedef struct {
-    /* 0x00 */ Collider base;
-    /* 0x18 */ s32 count;
-    /* 0x1C */ ColliderTrisElement* elements;
-} ColliderTris; // size = 0x20
-
-typedef struct {
-    /* 0x00 */ ColliderInit base;
-    /* 0x08 */ s32 count;
-    /* 0x0C */ ColliderTrisElementInit* elements;
-} ColliderTrisInit; // size = 0x10
-
-typedef struct {
-    /* 0x00 */ ColliderInitType1 base;
-    /* 0x08 */ s32 count;
-    /* 0x0C */ ColliderTrisElementInit* elements;
-} ColliderTrisInitType1; // size = 0x10
-
-typedef struct {
-    /* 0x00 */ Vec3f quad[4];
-    /* 0x30 */ Vec3s dcMid; // midpoint of vectors d, c
-    /* 0x36 */ Vec3s baMid; // midpoint of vectors b, a
-    /* 0x3C */ f32 acDistSq; // distance to nearest AC collision this frame, squared.
-} ColliderQuadDim; // size = 0x40
-
-typedef struct {
-    /* 0x00 */ Vec3f quad[4];
-} ColliderQuadDimInit; // size = 0x30
-
-typedef struct {
-    /* 0x00 */ ColliderInfo info;
-    /* 0x24 */ ColliderQuadDim dim;
-} ColliderQuadElement; // size = 0x68
-
-typedef struct {
-    /* 0x00 */ Collider base;
-    /* 0x18 */ ColliderInfo info;
-    /* 0x40 */ ColliderQuadDim dim;
-} ColliderQuad; // size = 0x80
-
-typedef struct {
-    /* 0x00 */ ColliderInit base;
-    /* 0x08 */ ColliderInfoInit info;
-    /* 0x20 */ ColliderQuadDimInit dim;
-} ColliderQuadInit; // size = 0x50
-
-typedef struct {
-    /* 0x00 */ ColliderInitType1 base;
-    /* 0x08 */ ColliderInfoInit info;
-    /* 0x20 */ ColliderQuadDimInit dim;
-} ColliderQuadInitType1; // size = 0x50
-
-typedef struct {
-    /* 0x00 */ Linef line;
-    /* 0x18 */ u16 ocFlags;
-} OcLine; // size = 0x1C
+/*
+ * Bases for all shapes of colliders
+ */
 
 typedef enum {
     /*  0 */ COLTYPE_HIT0, // Blue blood, white hitmark
@@ -254,6 +37,63 @@ typedef enum {
     /* 4 */ COLSHAPE_MAX
 } ColliderShape;
 
+typedef struct {
+    /* 0x00 */ struct Actor* actor; // Attached actor
+    /* 0x04 */ struct Actor* at; // Actor attached to what it collided with as an AT collider.
+    /* 0x08 */ struct Actor* ac; // Actor attached to what it collided with as an AC collider.
+    /* 0x0C */ struct Actor* oc; // Actor attached to what it collided with as an OC collider.
+    /* 0x10 */ u8 atFlags;
+    /* 0x11 */ u8 acFlags;
+    /* 0x12 */ u8 ocFlags1;
+    /* 0x13 */ u8 ocFlags2; // Flags related to which colliders it can OC collide with.
+    /* 0x14 */ u8 colType; // Determines hitmarks and sound effects during AC collisions. See `ColliderType` enum
+    /* 0x15 */ u8 shape; // See `ColliderShape` enum
+} Collider; // size = 0x18
+
+typedef struct {
+    /* 0x00 */ u8 colType;
+    /* 0x01 */ u8 atFlags;
+    /* 0x02 */ u8 acFlags;
+    /* 0x03 */ u8 ocFlags1;
+    /* 0x04 */ u8 ocFlags2;
+    /* 0x05 */ u8 shape;
+} ColliderInit; // size = 0x06
+
+typedef struct {
+    /* 0x00 */ u8 colType;
+    /* 0x01 */ u8 atFlags;
+    /* 0x02 */ u8 acFlags;
+    /* 0x03 */ u8 ocFlags1;
+    /* 0x04 */ u8 shape;
+} ColliderInitType1; // size = 0x05
+
+typedef struct {
+    /* 0x00 */ struct Actor* actor;
+    /* 0x04 */ u8 atFlags;
+    /* 0x05 */ u8 acFlags;
+    /* 0x06 */ u8 ocFlags1;
+    /* 0x07 */ u8 shape;
+} ColliderInitToActor; // size = 0x08
+
+typedef struct {
+    /* 0x00 */ u32 dmgFlags; // Toucher damage type flags.
+    /* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
+    /* 0x05 */ u8 damage; // Damage or Stun Timer
+} ColliderElementTouch; // size = 0x08
+
+typedef struct {
+    /* 0x00 */ u32 dmgFlags;  // Bumper damage type flags.
+    /* 0x04 */ u8 effect;  // Damage Effect (Knockback, Fire, etc.)
+    /* 0x05 */ u8 defense; // Damage Resistance
+    /* 0x06 */ Vec3s hitPos; // Point of contact
+} ColliderElementBump; // size = 0x0C
+
+typedef struct {
+    /* 0x00 */ u32 dmgFlags; // Bumper exclusion mask
+    /* 0x04 */ u8 effect; // Damage Effect (Knockback, Fire, etc.)
+    /* 0x05 */ u8 defense; // Damage Resistance
+} ColliderElementBumpInit; // size = 0x08
+
 /**
  * Affects the sound Link's sword makes when hitting it, hookability,
  * and possibly other things. It's definitely not flags, as all checks
@@ -271,7 +111,204 @@ typedef enum {
     /* 7 */ ELEMTYPE_UNK7
 } ElementType;
 
-#define SAC_ENABLE (1 << 0)
+typedef struct ColliderElement {
+    /* 0x00 */ ColliderElementTouch toucher; // Damage properties when acting as an AT collider
+    /* 0x08 */ ColliderElementBump bumper; // Damage properties when acting as an AC collider
+    /* 0x14 */ u8 elemType; // Affects sfx reaction when attacked by Link and hookability. Full purpose unknown.
+    /* 0x15 */ u8 toucherFlags; // Information flags for AT collisions
+    /* 0x16 */ u8 bumperFlags; // Information flags for AC collisions
+    /* 0x17 */ u8 ocElemFlags; // Information flags for OC collisions
+    /* 0x18 */ Collider* atHit; // object touching this element's AT collider
+    /* 0x1C */ Collider* acHit; // object touching this element's AC collider
+    /* 0x20 */ struct ColliderElement* atHitElem; // element that hit the AT collider
+    /* 0x24 */ struct ColliderElement* acHitElem; // element that hit the AC collider
+} ColliderElement; // size = 0x28
+
+typedef struct {
+    /* 0x00 */ u8 elemType; // Affects sfx reaction when attacked by Link and hookability. Full purpose unknown.
+    /* 0x04 */ ColliderElementTouch toucher; // Damage properties when acting as an AT collider
+    /* 0x0C */ ColliderElementBumpInit bumper; // Damage properties when acting as an AC collider
+    /* 0x14 */ u8 toucherFlags; // Information flags for AT collisions
+    /* 0x15 */ u8 bumperFlags;  // Information flags for AC collisions
+    /* 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
+    /* 0x10 */ f32 scale; // world space sphere = model * scale * 0.01
+    /* 0x14 */ u8 limb; // attached limb
+} ColliderJntSphElementDim; // size = 0x18
+
+typedef struct {
+    /* 0x00 */ ColliderElement base;
+    /* 0x28 */ ColliderJntSphElementDim dim;
+} ColliderJntSphElement; // size = 0x40
+
+typedef struct {
+    /* 0x00 */ Collider base;
+    /* 0x18 */ s32 count;
+    /* 0x1C */ ColliderJntSphElement* elements;
+} ColliderJntSph; // size = 0x20
+
+// init data structs
+
+typedef struct {
+    /* 0x00 */ u8 limb; // attached limb
+    /* 0x02 */ Sphere16 modelSphere; // model space sphere
+    /* 0x0A */ s16 scale; // world space sphere = model * scale * 0.01
+} ColliderJntSphElementDimInit; // size = 0x0C
+
+typedef struct {
+    /* 0x00 */ ColliderElementInit base;
+    /* 0x18 */ ColliderJntSphElementDimInit dim;
+} ColliderJntSphElementInit; // size = 0x24
+
+typedef struct {
+    /* 0x00 */ ColliderInit base;
+    /* 0x08 */ s32 count;
+    /* 0x0C */ ColliderJntSphElementInit* elements;
+} ColliderJntSphInit; // size = 0x10
+
+typedef struct {
+    /* 0x00 */ ColliderInitType1 base;
+    /* 0x08 */ s32 count;
+    /* 0x0C */ ColliderJntSphElementInit* elements;
+} ColliderJntSphInitType1; // size = 0x10
+
+typedef struct {
+    /* 0x00 */ ColliderInitToActor base;
+    /* 0x08 */ s32 count;
+    /* 0x0C */ ColliderJntSphElementInit* elements;
+} ColliderJntSphInitToActor; // size = 0x10
+
+/*
+ * Cylinder - A single cylinder shaped collider
+ */
+
+// collider structs
+
+typedef struct {
+    /* 0x00 */ Collider base;
+    /* 0x18 */ ColliderElement elem;
+    /* 0x40 */ Cylinder16 dim;
+} ColliderCylinder; // size = 0x4C
+
+// init data structs
+
+typedef struct {
+    /* 0x00 */ ColliderInit base;
+    /* 0x08 */ ColliderElementInit elem;
+    /* 0x20 */ Cylinder16 dim;
+} ColliderCylinderInit; // size = 0x2C
+
+typedef struct {
+    /* 0x00 */ ColliderInitType1 base;
+    /* 0x08 */ ColliderElementInit elem;
+    /* 0x20 */ Cylinder16 dim;
+} ColliderCylinderInitType1; // size = 0x2C
+
+typedef struct {
+    /* 0x00 */ ColliderInitToActor base;
+    /* 0x08 */ ColliderElementInit elem;
+    /* 0x20 */ Cylinder16 dim;
+} ColliderCylinderInitToActor; // size = 0x2C
+
+/*
+ * Tris - A collider made of triangle shaped elements
+ */
+
+// collider structs
+
+typedef struct {
+    /* 0x00 */ ColliderElement base;
+    /* 0x28 */ TriNorm dim;
+} ColliderTrisElement; // size = 0x5C
+
+typedef struct {
+    /* 0x00 */ Collider base;
+    /* 0x18 */ s32 count;
+    /* 0x1C */ ColliderTrisElement* elements;
+} ColliderTris; // size = 0x20
+
+// init data structs
+
+typedef struct {
+    /* 0x00 */ Vec3f vtx[3];
+} ColliderTrisElementDimInit; // size = 0x24
+
+typedef struct {
+    /* 0x00 */ ColliderElementInit base;
+    /* 0x18 */ ColliderTrisElementDimInit dim;
+} ColliderTrisElementInit; // size = 0x3C
+
+typedef struct {
+    /* 0x00 */ ColliderInit base;
+    /* 0x08 */ s32 count;
+    /* 0x0C */ ColliderTrisElementInit* elements;
+} ColliderTrisInit; // size = 0x10
+
+typedef struct {
+    /* 0x00 */ ColliderInitType1 base;
+    /* 0x08 */ s32 count;
+    /* 0x0C */ ColliderTrisElementInit* elements;
+} ColliderTrisInitType1; // size = 0x10
+
+/*
+ * Quad - A single quad shaped collider
+ */
+
+// collider structs
+
+typedef struct {
+    /* 0x00 */ Vec3f quad[4];
+    /* 0x30 */ Vec3s dcMid; // midpoint of vectors d, c
+    /* 0x36 */ Vec3s baMid; // midpoint of vectors b, a
+    /* 0x3C */ f32 acDistSq; // distance to nearest AC collision this frame, squared.
+} ColliderQuadDim; // size = 0x40
+
+typedef struct {
+    /* 0x00 */ Collider base;
+    /* 0x18 */ ColliderElement elem;
+    /* 0x40 */ ColliderQuadDim dim;
+} ColliderQuad; // size = 0x80
+
+// init data structs
+
+typedef struct {
+    /* 0x00 */ Vec3f quad[4];
+} ColliderQuadDimInit; // size = 0x30
+
+typedef struct {
+    /* 0x00 */ ColliderInit base;
+    /* 0x08 */ ColliderElementInit elem;
+    /* 0x20 */ ColliderQuadDimInit dim;
+} ColliderQuadInit; // size = 0x50
+
+typedef struct {
+    /* 0x00 */ ColliderInitType1 base;
+    /* 0x08 */ ColliderElementInit elem;
+    /* 0x20 */ ColliderQuadDimInit dim;
+} ColliderQuadInitType1; // size = 0x50
+
+/*
+ * Line collider
+ */
+
+typedef struct {
+    /* 0x00 */ Linef line;
+    /* 0x18 */ u16 ocFlags;
+} OcLine; // size = 0x1C
+
+/*
+ * Collider properties, for all shapes
+ */
 
 #define AT_NONE 0 // No flags set. Cannot have AT collisions when set as AT
 #define AT_ON (1 << 0) // Can have AT collisions when set as AT
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index f2cd50edce..0207725be6 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -4294,28 +4294,27 @@ u8 Actor_ApplyDamage(Actor* actor) {
     return actor->colChkInfo.health;
 }
 
-void Actor_SetDropFlag(Actor* actor, ColliderInfo* colInfo, s32 freezeFlag) {
-    if (colInfo->acHitInfo == NULL) {
+void Actor_SetDropFlag(Actor* actor, ColliderElement* elem, s32 freezeFlag) {
+    if (elem->acHitElem == NULL) {
         actor->dropFlag = 0x00;
-    } else if (freezeFlag &&
-               (colInfo->acHitInfo->toucher.dmgFlags & (DMG_UNKNOWN_1 | DMG_MAGIC_ICE | DMG_MAGIC_FIRE))) {
-        actor->freezeTimer = colInfo->acHitInfo->toucher.damage;
+    } else if (freezeFlag && (elem->acHitElem->toucher.dmgFlags & (DMG_UNKNOWN_1 | DMG_MAGIC_ICE | DMG_MAGIC_FIRE))) {
+        actor->freezeTimer = elem->acHitElem->toucher.damage;
         actor->dropFlag = 0x00;
-    } else if (colInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_FIRE) {
+    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_FIRE) {
         actor->dropFlag = 0x01;
-    } else if (colInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_ICE) {
+    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_ICE) {
         actor->dropFlag = 0x02;
-    } else if (colInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_UNK1) {
+    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK1) {
         actor->dropFlag = 0x04;
-    } else if (colInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_UNK2) {
+    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK2) {
         actor->dropFlag = 0x08;
-    } else if (colInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_UNK3) {
+    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK3) {
         actor->dropFlag = 0x10;
-    } else if (colInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_LIGHT) {
+    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_LIGHT) {
         actor->dropFlag = 0x20;
-    } else if (colInfo->acHitInfo->toucher.dmgFlags & DMG_MAGIC_LIGHT) {
+    } else if (elem->acHitElem->toucher.dmgFlags & DMG_MAGIC_LIGHT) {
         if (freezeFlag) {
-            actor->freezeTimer = colInfo->acHitInfo->toucher.damage;
+            actor->freezeTimer = elem->acHitElem->toucher.damage;
         }
         actor->dropFlag = 0x40;
     } else {
@@ -4324,35 +4323,35 @@ void Actor_SetDropFlag(Actor* actor, ColliderInfo* colInfo, s32 freezeFlag) {
 }
 
 void Actor_SetDropFlagJntSph(Actor* actor, ColliderJntSph* jntSph, s32 freezeFlag) {
-    ColliderInfo* curColInfo;
+    ColliderElement* elem;
     s32 flag;
     s32 i;
 
     actor->dropFlag = 0x00;
 
     for (i = jntSph->count - 1; i >= 0; i--) {
-        curColInfo = &jntSph->elements[i].info;
-        if (curColInfo->acHitInfo == NULL) {
+        elem = &jntSph->elements[i].base;
+        if (elem->acHitElem == NULL) {
             flag = 0x00;
         } else if (freezeFlag &&
-                   (curColInfo->acHitInfo->toucher.dmgFlags & (DMG_UNKNOWN_1 | DMG_MAGIC_ICE | DMG_MAGIC_FIRE))) {
-            actor->freezeTimer = curColInfo->acHitInfo->toucher.damage;
+                   (elem->acHitElem->toucher.dmgFlags & (DMG_UNKNOWN_1 | DMG_MAGIC_ICE | DMG_MAGIC_FIRE))) {
+            actor->freezeTimer = elem->acHitElem->toucher.damage;
             flag = 0x00;
-        } else if (curColInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_FIRE) {
+        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_FIRE) {
             flag = 0x01;
-        } else if (curColInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_ICE) {
+        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_ICE) {
             flag = 0x02;
-        } else if (curColInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_UNK1) {
+        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK1) {
             flag = 0x04;
-        } else if (curColInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_UNK2) {
+        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK2) {
             flag = 0x08;
-        } else if (curColInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_UNK3) {
+        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK3) {
             flag = 0x10;
-        } else if (curColInfo->acHitInfo->toucher.dmgFlags & DMG_ARROW_LIGHT) {
+        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_LIGHT) {
             flag = 0x20;
-        } else if (curColInfo->acHitInfo->toucher.dmgFlags & DMG_MAGIC_LIGHT) {
+        } else if (elem->acHitElem->toucher.dmgFlags & DMG_MAGIC_LIGHT) {
             if (freezeFlag) {
-                actor->freezeTimer = curColInfo->acHitInfo->toucher.damage;
+                actor->freezeTimer = elem->acHitElem->toucher.damage;
             }
             flag = 0x40;
         } else {
diff --git a/src/code/z_collision_check.c b/src/code/z_collision_check.c
index 26d91b347e..bf0bafeadf 100644
--- a/src/code/z_collision_check.c
+++ b/src/code/z_collision_check.c
@@ -3,40 +3,10 @@
 #include "overlays/effects/ovl_Effect_Ss_HitMark/z_eff_ss_hitmark.h"
 
 typedef s32 (*ColChkResetFunc)(PlayState*, Collider*);
-typedef void (*ColChkBloodFunc)(PlayState*, Collider*, Vec3f*);
 typedef void (*ColChkApplyFunc)(PlayState*, CollisionCheckContext*, Collider*);
 typedef void (*ColChkVsFunc)(PlayState*, CollisionCheckContext*, Collider*, Collider*);
 typedef s32 (*ColChkLineFunc)(PlayState*, CollisionCheckContext*, Collider*, Vec3f*, Vec3f*);
 
-typedef struct {
-    /* 0 */ u8 blood;
-    /* 1 */ u8 effect;
-} HitInfo; // size = 0x2
-
-typedef enum {
-    /* 0 */ BLOOD_NONE,
-    /* 1 */ BLOOD_BLUE,
-    /* 2 */ BLOOD_GREEN,
-    /* 3 */ BLOOD_WATER,
-    /* 4 */ BLOOD_RED,
-    /* 5 */ BLOOD_RED2
-} ColChkBloodType;
-
-typedef enum {
-    /* 0 */ HIT_WHITE,
-    /* 1 */ HIT_DUST,
-    /* 2 */ HIT_RED,
-    /* 3 */ HIT_SOLID,
-    /* 4 */ HIT_WOOD,
-    /* 5 */ HIT_NONE
-} ColChkHitType;
-
-typedef enum {
-    /* 0 */ MASSTYPE_IMMOVABLE,
-    /* 1 */ MASSTYPE_HEAVY,
-    /* 2 */ MASSTYPE_NORMAL
-} ColChkMassType;
-
 /**
  * Draws a red triangle with vertices vA, vB, and vC.
  */
@@ -100,114 +70,114 @@ void Collider_DrawPoly(GraphicsContext* gfxCtx, Vec3f* vA, Vec3f* vB, Vec3f* vC,
     CLOSE_DISPS(gfxCtx, "../z_collision_check.c", 757);
 }
 
-s32 Collider_InitBase(PlayState* play, Collider* collider) {
+s32 Collider_InitBase(PlayState* play, Collider* col) {
     static Collider init = {
         NULL, NULL, NULL, NULL, AT_NONE, AC_NONE, OC1_NONE, OC2_NONE, COLTYPE_HIT3, COLSHAPE_MAX,
     };
 
-    *collider = init;
+    *col = init;
     return true;
 }
 
-s32 Collider_DestroyBase(PlayState* play, Collider* collider) {
+s32 Collider_DestroyBase(PlayState* play, Collider* col) {
     return true;
 }
 
 /**
  * Uses default OC2_TYPE_1 and COLTYPE_HIT0
  */
-s32 Collider_SetBaseToActor(PlayState* play, Collider* collider, ColliderInitToActor* src) {
-    collider->actor = src->actor;
-    collider->atFlags = src->atFlags;
-    collider->acFlags = src->acFlags;
-    collider->ocFlags1 = src->ocFlags1;
-    collider->ocFlags2 = OC2_TYPE_1;
-    collider->shape = src->shape;
+s32 Collider_SetBaseToActor(PlayState* play, Collider* col, ColliderInitToActor* src) {
+    col->actor = src->actor;
+    col->atFlags = src->atFlags;
+    col->acFlags = src->acFlags;
+    col->ocFlags1 = src->ocFlags1;
+    col->ocFlags2 = OC2_TYPE_1;
+    col->shape = src->shape;
     return true;
 }
 
 /**
  * Uses default OC2_TYPE_1
  */
-s32 Collider_SetBaseType1(PlayState* play, Collider* collider, Actor* actor, ColliderInitType1* src) {
-    collider->actor = actor;
-    collider->colType = src->colType;
-    collider->atFlags = src->atFlags;
-    collider->acFlags = src->acFlags;
-    collider->ocFlags1 = src->ocFlags1;
-    collider->ocFlags2 = OC2_TYPE_1;
-    collider->shape = src->shape;
+s32 Collider_SetBaseType1(PlayState* play, Collider* col, Actor* actor, ColliderInitType1* src) {
+    col->actor = actor;
+    col->colType = src->colType;
+    col->atFlags = src->atFlags;
+    col->acFlags = src->acFlags;
+    col->ocFlags1 = src->ocFlags1;
+    col->ocFlags2 = OC2_TYPE_1;
+    col->shape = src->shape;
     return true;
 }
 
-s32 Collider_SetBase(PlayState* play, Collider* collider, Actor* actor, ColliderInit* src) {
-    collider->actor = actor;
-    collider->colType = src->colType;
-    collider->atFlags = src->atFlags;
-    collider->acFlags = src->acFlags;
-    collider->ocFlags1 = src->ocFlags1;
-    collider->ocFlags2 = src->ocFlags2;
-    collider->shape = src->shape;
+s32 Collider_SetBase(PlayState* play, Collider* col, Actor* actor, ColliderInit* src) {
+    col->actor = actor;
+    col->colType = src->colType;
+    col->atFlags = src->atFlags;
+    col->acFlags = src->acFlags;
+    col->ocFlags1 = src->ocFlags1;
+    col->ocFlags2 = src->ocFlags2;
+    col->shape = src->shape;
     return true;
 }
 
-void Collider_ResetATBase(PlayState* play, Collider* collider) {
-    collider->at = NULL;
-    collider->atFlags &= ~(AT_HIT | AT_BOUNCED);
+void Collider_ResetATBase(PlayState* play, Collider* col) {
+    col->at = NULL;
+    col->atFlags &= ~(AT_HIT | AT_BOUNCED);
 }
 
-void Collider_ResetACBase(PlayState* play, Collider* collider) {
-    collider->ac = NULL;
-    collider->acFlags &= ~(AC_HIT | AC_BOUNCED);
+void Collider_ResetACBase(PlayState* play, Collider* col) {
+    col->ac = NULL;
+    col->acFlags &= ~(AC_HIT | AC_BOUNCED);
 }
 
-void Collider_ResetOCBase(PlayState* play, Collider* collider) {
-    collider->oc = NULL;
-    collider->ocFlags1 &= ~OC1_HIT;
-    collider->ocFlags2 &= ~OC2_HIT_PLAYER;
+void Collider_ResetOCBase(PlayState* play, Collider* col) {
+    col->oc = NULL;
+    col->ocFlags1 &= ~OC1_HIT;
+    col->ocFlags2 &= ~OC2_HIT_PLAYER;
 }
 
-s32 Collider_InitTouch(PlayState* play, ColliderTouch* touch) {
-    static ColliderTouch init = { 0x00000000, 0, 0 };
+s32 Collider_InitElementTouch(PlayState* play, ColliderElementTouch* touch) {
+    static ColliderElementTouch init = { 0x00000000, 0, 0 };
 
     *touch = init;
     return true;
 }
 
-s32 Collider_DestroyTouch(PlayState* play, ColliderTouch* touch) {
+s32 Collider_DestroyElementTouch(PlayState* play, ColliderElementTouch* touch) {
     return true;
 }
 
-s32 Collider_SetTouch(PlayState* play, ColliderTouch* dest, ColliderTouch* src) {
+s32 Collider_SetElementTouch(PlayState* play, ColliderElementTouch* dest, ColliderElementTouch* src) {
     dest->dmgFlags = src->dmgFlags;
     dest->effect = src->effect;
     dest->damage = src->damage;
     return true;
 }
 
-void Collider_ResetATInfo_Unk(PlayState* play, ColliderInfo* info) {
+void Collider_ResetATElement_Unk(PlayState* play, ColliderElement* elem) {
 }
 
-s32 Collider_InitBump(PlayState* play, ColliderBump* bump) {
-    static ColliderBump init = { 0xFFCFFFFF, 0, 0, { 0, 0, 0 } };
+s32 Collider_InitElementBump(PlayState* play, ColliderElementBump* bump) {
+    static ColliderElementBump init = { 0xFFCFFFFF, 0, 0, { 0, 0, 0 } };
 
     *bump = init;
     return true;
 }
 
-s32 Collider_DestroyBump(PlayState* play, ColliderBump* bump) {
+s32 Collider_DestroyElementBump(PlayState* play, ColliderElementBump* bump) {
     return true;
 }
 
-s32 Collider_SetBump(PlayState* play, ColliderBump* bump, ColliderBumpInit* init) {
+s32 Collider_SetElementBump(PlayState* play, ColliderElementBump* bump, ColliderElementBumpInit* init) {
     bump->dmgFlags = init->dmgFlags;
     bump->effect = init->effect;
     bump->defense = init->defense;
     return true;
 }
 
-s32 Collider_InitInfo(PlayState* play, ColliderInfo* info) {
-    static ColliderInfo init = {
+s32 Collider_InitElement(PlayState* play, ColliderElement* elem) {
+    static ColliderElement init = {
         { 0, 0, 0 },   { 0xFFCFFFFF, 0, 0, { 0, 0, 0 } },
         ELEMTYPE_UNK0, TOUCH_NONE,
         BUMP_NONE,     OCELEM_NONE,
@@ -215,46 +185,46 @@ s32 Collider_InitInfo(PlayState* play, ColliderInfo* info) {
         NULL,          NULL,
     };
 
-    *info = init;
-    Collider_InitTouch(play, &info->toucher);
-    Collider_InitBump(play, &info->bumper);
+    *elem = init;
+    Collider_InitElementTouch(play, &elem->toucher);
+    Collider_InitElementBump(play, &elem->bumper);
     return true;
 }
 
-s32 Collider_DestroyInfo(PlayState* play, ColliderInfo* info) {
-    Collider_DestroyTouch(play, &info->toucher);
-    Collider_DestroyBump(play, &info->bumper);
+s32 Collider_DestroyElement(PlayState* play, ColliderElement* elem) {
+    Collider_DestroyElementTouch(play, &elem->toucher);
+    Collider_DestroyElementBump(play, &elem->bumper);
     return true;
 }
 
-s32 Collider_SetInfo(PlayState* play, ColliderInfo* info, ColliderInfoInit* infoInit) {
-    info->elemType = infoInit->elemType;
-    Collider_SetTouch(play, &info->toucher, &infoInit->toucher);
-    Collider_SetBump(play, &info->bumper, &infoInit->bumper);
-    info->toucherFlags = infoInit->toucherFlags;
-    info->bumperFlags = infoInit->bumperFlags;
-    info->ocElemFlags = infoInit->ocElemFlags;
+s32 Collider_SetElement(PlayState* play, ColliderElement* elem, ColliderElementInit* elemInit) {
+    elem->elemType = elemInit->elemType;
+    Collider_SetElementTouch(play, &elem->toucher, &elemInit->toucher);
+    Collider_SetElementBump(play, &elem->bumper, &elemInit->bumper);
+    elem->toucherFlags = elemInit->toucherFlags;
+    elem->bumperFlags = elemInit->bumperFlags;
+    elem->ocElemFlags = elemInit->ocElemFlags;
     return true;
 }
 
-void Collider_ResetATInfo(PlayState* play, ColliderInfo* info) {
-    info->atHit = NULL;
-    info->atHitInfo = NULL;
-    info->toucherFlags &= ~TOUCH_HIT;
-    info->toucherFlags &= ~TOUCH_DREW_HITMARK;
-    Collider_ResetATInfo_Unk(play, info);
+void Collider_ResetATElement(PlayState* play, ColliderElement* elem) {
+    elem->atHit = NULL;
+    elem->atHitElem = NULL;
+    elem->toucherFlags &= ~TOUCH_HIT;
+    elem->toucherFlags &= ~TOUCH_DREW_HITMARK;
+    Collider_ResetATElement_Unk(play, elem);
 }
 
-void Collider_ResetACInfo(PlayState* play, ColliderInfo* info) {
-    info->bumper.hitPos.x = info->bumper.hitPos.y = info->bumper.hitPos.z = 0;
-    info->bumperFlags &= ~BUMP_HIT;
-    info->bumperFlags &= ~BUMP_DRAW_HITMARK;
-    info->acHit = NULL;
-    info->acHitInfo = NULL;
+void Collider_ResetACElement(PlayState* play, ColliderElement* elem) {
+    elem->bumper.hitPos.x = elem->bumper.hitPos.y = elem->bumper.hitPos.z = 0;
+    elem->bumperFlags &= ~BUMP_HIT;
+    elem->bumperFlags &= ~BUMP_DRAW_HITMARK;
+    elem->acHit = NULL;
+    elem->acHitElem = NULL;
 }
 
-void Collider_ResetOCInfo(PlayState* play, ColliderInfo* info) {
-    info->ocElemFlags &= ~OCELEM_HIT;
+void Collider_ResetOCElement(PlayState* play, ColliderElement* elem) {
+    elem->ocElemFlags &= ~OCELEM_HIT;
 }
 
 s32 Collider_InitJntSphElementDim(PlayState* play, ColliderJntSphElementDim* dim) {
@@ -268,7 +238,7 @@ s32 Collider_InitJntSphElementDim(PlayState* play, ColliderJntSphElementDim* dim
     return true;
 }
 
-s32 Collider_DestroyJntSphElementDim(PlayState* play, ColliderJntSphElementDim* element) {
+s32 Collider_DestroyJntSphElementDim(PlayState* play, ColliderJntSphElementDim* dim) {
     return true;
 }
 
@@ -279,80 +249,80 @@ s32 Collider_SetJntSphElementDim(PlayState* play, ColliderJntSphElementDim* dest
     return true;
 }
 
-s32 Collider_InitJntSphElement(PlayState* play, ColliderJntSphElement* element) {
-    Collider_InitInfo(play, &element->info);
-    Collider_InitJntSphElementDim(play, &element->dim);
+s32 Collider_InitJntSphElement(PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_InitElement(play, &jntSphElem->base);
+    Collider_InitJntSphElementDim(play, &jntSphElem->dim);
     return true;
 }
 
-s32 Collider_DestroyJntSphElement(PlayState* play, ColliderJntSphElement* element) {
-    Collider_DestroyInfo(play, &element->info);
-    Collider_DestroyJntSphElementDim(play, &element->dim);
+s32 Collider_DestroyJntSphElement(PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_DestroyElement(play, &jntSphElem->base);
+    Collider_DestroyJntSphElementDim(play, &jntSphElem->dim);
     return true;
 }
 
 s32 Collider_SetJntSphElement(PlayState* play, ColliderJntSphElement* dest, ColliderJntSphElementInit* src) {
-    Collider_SetInfo(play, &dest->info, &src->info);
+    Collider_SetElement(play, &dest->base, &src->base);
     Collider_SetJntSphElementDim(play, &dest->dim, &src->dim);
     return true;
 }
 
-s32 Collider_ResetJntSphElementAT(PlayState* play, ColliderJntSphElement* collider) {
-    Collider_ResetATInfo(play, &collider->info);
+s32 Collider_ResetJntSphElementAT(PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_ResetATElement(play, &jntSphElem->base);
     return true;
 }
 
-s32 Collider_ResetJntSphElementAC(PlayState* play, ColliderJntSphElement* collider) {
-    Collider_ResetACInfo(play, &collider->info);
+s32 Collider_ResetJntSphElementAC(PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_ResetACElement(play, &jntSphElem->base);
     return true;
 }
 
-s32 Collider_ResetJntSphElementOC(PlayState* play, ColliderJntSphElement* collider) {
-    Collider_ResetOCInfo(play, &collider->info);
+s32 Collider_ResetJntSphElementOC(PlayState* play, ColliderJntSphElement* jntSphElem) {
+    Collider_ResetOCElement(play, &jntSphElem->base);
     return true;
 }
 
 /**
  * Initializes a ColliderJntSph to default values
  */
-s32 Collider_InitJntSph(PlayState* play, ColliderJntSph* collider) {
-    Collider_InitBase(play, &collider->base);
-    collider->count = 0;
-    collider->elements = NULL;
+s32 Collider_InitJntSph(PlayState* play, ColliderJntSph* jntSph) {
+    Collider_InitBase(play, &jntSph->base);
+    jntSph->count = 0;
+    jntSph->elements = NULL;
     return true;
 }
 
 /**
  * Destroys a dynamically allocated ColliderJntSph
  */
-s32 Collider_FreeJntSph(PlayState* play, ColliderJntSph* collider) {
-    ColliderJntSphElement* element;
+s32 Collider_FreeJntSph(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) {
-        ZELDA_ARENA_FREE(collider->elements, "../z_collision_check.c", 1393);
+    jntSph->count = 0;
+    if (jntSph->elements != NULL) {
+        ZELDA_ARENA_FREE(jntSph->elements, "../z_collision_check.c", 1393);
     }
-    collider->elements = NULL;
+    jntSph->elements = NULL;
     return true;
 }
 
 /**
  * Destroys a preallocated ColliderJntSph
  */
-s32 Collider_DestroyJntSph(PlayState* play, ColliderJntSph* collider) {
-    ColliderJntSphElement* element;
+s32 Collider_DestroyJntSph(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;
-    collider->elements = NULL;
+    jntSph->count = 0;
+    jntSph->elements = NULL;
     return true;
 }
 
@@ -443,13 +413,13 @@ s32 Collider_SetJntSphAlloc(PlayState* play, ColliderJntSph* dest, Actor* actor,
  * Sets up the ColliderJntSph using the values in src, placing the element array in elements.
  */
 s32 Collider_SetJntSph(PlayState* play, ColliderJntSph* dest, Actor* actor, ColliderJntSphInit* src,
-                       ColliderJntSphElement* elements) {
+                       ColliderJntSphElement* jntSphElements) {
     ColliderJntSphElement* destElem;
     ColliderJntSphElementInit* srcElem;
 
     Collider_SetBase(play, &dest->base, actor, &src->base);
     dest->count = src->count;
-    dest->elements = elements;
+    dest->elements = jntSphElements;
     ASSERT(dest->elements != NULL, "pclobj_jntsph->elem_tbl != NULL", "../z_collision_check.c", 1603);
 
     for (destElem = dest->elements, srcElem = src->elements; destElem < dest->elements + dest->count;
@@ -463,14 +433,14 @@ s32 Collider_SetJntSph(PlayState* play, ColliderJntSph* dest, Actor* actor, Coll
 /**
  * Resets the collider's AT collision flags.
  */
-s32 Collider_ResetJntSphAT(PlayState* play, Collider* collider) {
-    ColliderJntSphElement* element;
-    ColliderJntSph* jntSph = (ColliderJntSph*)collider;
+s32 Collider_ResetJntSphAT(PlayState* play, Collider* col) {
+    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 true;
 }
@@ -478,14 +448,14 @@ s32 Collider_ResetJntSphAT(PlayState* play, Collider* collider) {
 /**
  * Resets the collider's AC collision flags.
  */
-s32 Collider_ResetJntSphAC(PlayState* play, Collider* collider) {
-    ColliderJntSphElement* element;
-    ColliderJntSph* jntSph = (ColliderJntSph*)collider;
+s32 Collider_ResetJntSphAC(PlayState* play, Collider* col) {
+    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 true;
 }
@@ -493,14 +463,14 @@ s32 Collider_ResetJntSphAC(PlayState* play, Collider* collider) {
 /**
  * Resets the collider's OC collision flags.
  */
-s32 Collider_ResetJntSphOC(PlayState* play, Collider* collider) {
-    ColliderJntSphElement* element;
-    ColliderJntSph* jntSph = (ColliderJntSph*)collider;
+s32 Collider_ResetJntSphOC(PlayState* play, Collider* col) {
+    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 true;
 }
@@ -524,20 +494,20 @@ s32 Collider_SetCylinderDim(PlayState* play, Cylinder16* dest, Cylinder16* src)
 /**
  * Initializes a ColliderCylinder to default values
  */
-s32 Collider_InitCylinder(PlayState* play, ColliderCylinder* collider) {
-    Collider_InitBase(play, &collider->base);
-    Collider_InitInfo(play, &collider->info);
-    Collider_InitCylinderDim(play, &collider->dim);
+s32 Collider_InitCylinder(PlayState* play, ColliderCylinder* cyl) {
+    Collider_InitBase(play, &cyl->base);
+    Collider_InitElement(play, &cyl->elem);
+    Collider_InitCylinderDim(play, &cyl->dim);
     return true;
 }
 
 /**
  * Destroys a ColliderCylinder
  */
-s32 Collider_DestroyCylinder(PlayState* play, ColliderCylinder* collider) {
-    Collider_DestroyBase(play, &collider->base);
-    Collider_DestroyInfo(play, &collider->info);
-    Collider_DestroyCylinderDim(play, &collider->dim);
+s32 Collider_DestroyCylinder(PlayState* play, ColliderCylinder* cyl) {
+    Collider_DestroyBase(play, &cyl->base);
+    Collider_DestroyElement(play, &cyl->elem);
+    Collider_DestroyCylinderDim(play, &cyl->dim);
     return true;
 }
 
@@ -545,64 +515,63 @@ s32 Collider_DestroyCylinder(PlayState* play, ColliderCylinder* collider) {
  * Sets up the ColliderCylinder using the values in src and sets it to the actor specified in src. Uses default
  * OC2_TYPE_1 and COLTYPE_0. Used only by DekuJr, who sets it to himself anyways.
  */
-s32 Collider_SetCylinderToActor(PlayState* play, ColliderCylinder* collider, ColliderCylinderInitToActor* src) {
-    Collider_SetBaseToActor(play, &collider->base, &src->base);
-    Collider_SetInfo(play, &collider->info, &src->info);
-    Collider_SetCylinderDim(play, &collider->dim, &src->dim);
+s32 Collider_SetCylinderToActor(PlayState* play, ColliderCylinder* dest, ColliderCylinderInitToActor* src) {
+    Collider_SetBaseToActor(play, &dest->base, &src->base);
+    Collider_SetElement(play, &dest->elem, &src->elem);
+    Collider_SetCylinderDim(play, &dest->dim, &src->dim);
     return true;
 }
 
 /**
  * Sets up the ColliderCylinder using the values in src. Uses default OC2_TYPE_1
  */
-s32 Collider_SetCylinderType1(PlayState* play, ColliderCylinder* collider, Actor* actor,
-                              ColliderCylinderInitType1* src) {
-    Collider_SetBaseType1(play, &collider->base, actor, &src->base);
-    Collider_SetInfo(play, &collider->info, &src->info);
-    Collider_SetCylinderDim(play, &collider->dim, &src->dim);
+s32 Collider_SetCylinderType1(PlayState* play, ColliderCylinder* dest, Actor* actor, ColliderCylinderInitType1* src) {
+    Collider_SetBaseType1(play, &dest->base, actor, &src->base);
+    Collider_SetElement(play, &dest->elem, &src->elem);
+    Collider_SetCylinderDim(play, &dest->dim, &src->dim);
     return true;
 }
 
 /**
  * Sets up the ColliderCylinder using the values in src.
  */
-s32 Collider_SetCylinder(PlayState* play, ColliderCylinder* collider, Actor* actor, ColliderCylinderInit* src) {
-    Collider_SetBase(play, &collider->base, actor, &src->base);
-    Collider_SetInfo(play, &collider->info, &src->info);
-    Collider_SetCylinderDim(play, &collider->dim, &src->dim);
+s32 Collider_SetCylinder(PlayState* play, ColliderCylinder* dest, Actor* actor, ColliderCylinderInit* src) {
+    Collider_SetBase(play, &dest->base, actor, &src->base);
+    Collider_SetElement(play, &dest->elem, &src->elem);
+    Collider_SetCylinderDim(play, &dest->dim, &src->dim);
     return true;
 }
 
 /**
  * Resets the collider's AT collision flags.
  */
-s32 Collider_ResetCylinderAT(PlayState* play, Collider* collider) {
-    ColliderCylinder* cylinder = (ColliderCylinder*)collider;
+s32 Collider_ResetCylinderAT(PlayState* play, Collider* col) {
+    ColliderCylinder* cyl = (ColliderCylinder*)col;
 
-    Collider_ResetATBase(play, &cylinder->base);
-    Collider_ResetATInfo(play, &cylinder->info);
+    Collider_ResetATBase(play, &cyl->base);
+    Collider_ResetATElement(play, &cyl->elem);
     return true;
 }
 
 /**
  * Resets the collider's AC collision flags.
  */
-s32 Collider_ResetCylinderAC(PlayState* play, Collider* collider) {
-    ColliderCylinder* cylinder = (ColliderCylinder*)collider;
+s32 Collider_ResetCylinderAC(PlayState* play, Collider* col) {
+    ColliderCylinder* cyl = (ColliderCylinder*)col;
 
-    Collider_ResetACBase(play, &cylinder->base);
-    Collider_ResetACInfo(play, &cylinder->info);
+    Collider_ResetACBase(play, &cyl->base);
+    Collider_ResetACElement(play, &cyl->elem);
     return true;
 }
 
 /**
  * Resets the collider's OC collision flags.
  */
-s32 Collider_ResetCylinderOC(PlayState* play, Collider* collider) {
-    ColliderCylinder* cylinder = (ColliderCylinder*)collider;
+s32 Collider_ResetCylinderOC(PlayState* play, Collider* col) {
+    ColliderCylinder* cyl = (ColliderCylinder*)col;
 
-    Collider_ResetOCBase(play, &cylinder->base);
-    Collider_ResetOCInfo(play, &cylinder->info);
+    Collider_ResetOCBase(play, &cyl->base);
+    Collider_ResetOCElement(play, &cyl->elem);
     return true;
 }
 
@@ -641,36 +610,36 @@ s32 Collider_SetTrisElementDim(PlayState* play, TriNorm* dest, ColliderTrisEleme
     return true;
 }
 
-s32 Collider_InitTrisElement(PlayState* play, ColliderTrisElement* collider) {
-    Collider_InitInfo(play, &collider->info);
-    Collider_InitTrisElementDim(play, &collider->dim);
+s32 Collider_InitTrisElement(PlayState* play, ColliderTrisElement* trisElem) {
+    Collider_InitElement(play, &trisElem->base);
+    Collider_InitTrisElementDim(play, &trisElem->dim);
     return true;
 }
 
-s32 Collider_DestroyTrisElement(PlayState* play, ColliderTrisElement* collider) {
-    Collider_DestroyInfo(play, &collider->info);
-    Collider_DestroyTrisElementDim(play, &collider->dim);
+s32 Collider_DestroyTrisElement(PlayState* play, ColliderTrisElement* trisElem) {
+    Collider_DestroyElement(play, &trisElem->base);
+    Collider_DestroyTrisElementDim(play, &trisElem->dim);
     return true;
 }
 
 s32 Collider_SetTrisElement(PlayState* play, ColliderTrisElement* dest, ColliderTrisElementInit* src) {
-    Collider_SetInfo(play, &dest->info, &src->info);
+    Collider_SetElement(play, &dest->base, &src->base);
     Collider_SetTrisElementDim(play, &dest->dim, &src->dim);
     return true;
 }
 
-s32 Collider_ResetTrisElementAT(PlayState* play, ColliderTrisElement* element) {
-    Collider_ResetATInfo(play, &element->info);
+s32 Collider_ResetTrisElementAT(PlayState* play, ColliderTrisElement* trisElem) {
+    Collider_ResetATElement(play, &trisElem->base);
     return true;
 }
 
-s32 Collider_ResetTrisElementAC(PlayState* play, ColliderTrisElement* element) {
-    Collider_ResetACInfo(play, &element->info);
+s32 Collider_ResetTrisElementAC(PlayState* play, ColliderTrisElement* trisElem) {
+    Collider_ResetACElement(play, &trisElem->base);
     return true;
 }
 
-s32 Collider_ResetTrisElementOC(PlayState* play, ColliderTrisElement* element) {
-    Collider_ResetOCInfo(play, &element->info);
+s32 Collider_ResetTrisElementOC(PlayState* play, ColliderTrisElement* trisElem) {
+    Collider_ResetOCElement(play, &trisElem->base);
     return true;
 }
 
@@ -689,11 +658,11 @@ s32 Collider_InitTris(PlayState* play, ColliderTris* tris) {
  * Unused
  */
 s32 Collider_FreeTris(PlayState* play, ColliderTris* tris) {
-    ColliderTrisElement* element;
+    ColliderTrisElement* trisElem;
 
     Collider_DestroyBase(play, &tris->base);
-    for (element = tris->elements; element < tris->elements + tris->count; element++) {
-        Collider_DestroyTrisElement(play, element);
+    for (trisElem = tris->elements; trisElem < tris->elements + tris->count; trisElem++) {
+        Collider_DestroyTrisElement(play, trisElem);
     }
 
     tris->count = 0;
@@ -708,11 +677,11 @@ s32 Collider_FreeTris(PlayState* play, ColliderTris* tris) {
  * Destroys a preallocated ColliderTris
  */
 s32 Collider_DestroyTris(PlayState* play, ColliderTris* tris) {
-    ColliderTrisElement* element;
+    ColliderTrisElement* trisElem;
 
     Collider_DestroyBase(play, &tris->base);
-    for (element = tris->elements; element < tris->elements + tris->count; element++) {
-        Collider_DestroyTrisElement(play, element);
+    for (trisElem = tris->elements; trisElem < tris->elements + tris->count; trisElem++) {
+        Collider_DestroyTrisElement(play, trisElem);
     }
 
     tris->count = 0;
@@ -778,13 +747,13 @@ s32 Collider_SetTrisAlloc(PlayState* play, ColliderTris* dest, Actor* actor, Col
  * Sets up the ColliderTris using the values in src, placing the element array in elements.
  */
 s32 Collider_SetTris(PlayState* play, ColliderTris* dest, Actor* actor, ColliderTrisInit* src,
-                     ColliderTrisElement* elements) {
+                     ColliderTrisElement* trisElements) {
     ColliderTrisElement* destElem;
     ColliderTrisElementInit* srcElem;
 
     Collider_SetBase(play, &dest->base, actor, &src->base);
     dest->count = src->count;
-    dest->elements = elements;
+    dest->elements = trisElements;
     ASSERT(dest->elements != NULL, "pclobj_tris->elem_tbl != NULL", "../z_collision_check.c", 2258);
 
     for (destElem = dest->elements, srcElem = src->elements; destElem < dest->elements + dest->count;
@@ -798,13 +767,13 @@ s32 Collider_SetTris(PlayState* play, ColliderTris* dest, Actor* actor, Collider
 /**
  * Resets the collider's AT collision flags.
  */
-s32 Collider_ResetTrisAT(PlayState* play, Collider* collider) {
-    ColliderTrisElement* element;
-    ColliderTris* tris = (ColliderTris*)collider;
+s32 Collider_ResetTrisAT(PlayState* play, Collider* col) {
+    ColliderTrisElement* trisElem;
+    ColliderTris* tris = (ColliderTris*)col;
 
     Collider_ResetATBase(play, &tris->base);
-    for (element = tris->elements; element < tris->elements + tris->count; element++) {
-        Collider_ResetTrisElementAT(play, element);
+    for (trisElem = tris->elements; trisElem < tris->elements + tris->count; trisElem++) {
+        Collider_ResetTrisElementAT(play, trisElem);
     }
     return true;
 }
@@ -812,13 +781,13 @@ s32 Collider_ResetTrisAT(PlayState* play, Collider* collider) {
 /**
  * Resets the collider's AC collision flags.
  */
-s32 Collider_ResetTrisAC(PlayState* play, Collider* collider) {
-    ColliderTrisElement* element;
-    ColliderTris* tris = (ColliderTris*)collider;
+s32 Collider_ResetTrisAC(PlayState* play, Collider* col) {
+    ColliderTrisElement* trisElem;
+    ColliderTris* tris = (ColliderTris*)col;
 
     Collider_ResetACBase(play, &tris->base);
-    for (element = tris->elements; element < tris->elements + tris->count; element++) {
-        Collider_ResetTrisElementAC(play, element);
+    for (trisElem = tris->elements; trisElem < tris->elements + tris->count; trisElem++) {
+        Collider_ResetTrisElementAC(play, trisElem);
     }
     return true;
 }
@@ -826,13 +795,13 @@ s32 Collider_ResetTrisAC(PlayState* play, Collider* collider) {
 /**
  * Resets the collider's OC collision flags.
  */
-s32 Collider_ResetTrisOC(PlayState* play, Collider* collider) {
-    ColliderTrisElement* element;
-    ColliderTris* tris = (ColliderTris*)collider;
+s32 Collider_ResetTrisOC(PlayState* play, Collider* col) {
+    ColliderTrisElement* trisElem;
+    ColliderTris* tris = (ColliderTris*)col;
 
     Collider_ResetOCBase(play, &tris->base);
-    for (element = tris->elements; element < tris->elements + tris->count; element++) {
-        Collider_ResetTrisElementOC(play, element);
+    for (trisElem = tris->elements; trisElem < tris->elements + tris->count; trisElem++) {
+        Collider_ResetTrisElementOC(play, trisElem);
     }
     return true;
 }
@@ -879,51 +848,51 @@ s32 Collider_SetQuadDim(PlayState* play, ColliderQuadDim* dest, ColliderQuadDimI
 /**
  * Initializes a ColliderQuad to default values.
  */
-s32 Collider_InitQuad(PlayState* play, ColliderQuad* collider) {
-    Collider_InitBase(play, &collider->base);
-    Collider_InitInfo(play, &collider->info);
-    Collider_InitQuadDim(play, &collider->dim);
+s32 Collider_InitQuad(PlayState* play, ColliderQuad* quad) {
+    Collider_InitBase(play, &quad->base);
+    Collider_InitElement(play, &quad->elem);
+    Collider_InitQuadDim(play, &quad->dim);
     return true;
 }
 
 /**
  * Destroys a ColliderQuad.
  */
-s32 Collider_DestroyQuad(PlayState* play, ColliderQuad* collider) {
-    Collider_DestroyBase(play, &collider->base);
-    Collider_DestroyInfo(play, &collider->info);
-    Collider_DestroyQuadDim(play, &collider->dim);
+s32 Collider_DestroyQuad(PlayState* play, ColliderQuad* quad) {
+    Collider_DestroyBase(play, &quad->base);
+    Collider_DestroyElement(play, &quad->elem);
+    Collider_DestroyQuadDim(play, &quad->dim);
     return true;
 }
 
 /**
  * Sets up the ColliderQuad using the values in src. Uses the default OC2_TYPE_1
  */
-s32 Collider_SetQuadType1(PlayState* play, ColliderQuad* collider, Actor* actor, ColliderQuadInitType1* src) {
-    Collider_SetBaseType1(play, &collider->base, actor, &src->base);
-    Collider_SetInfo(play, &collider->info, &src->info);
-    Collider_SetQuadDim(play, &collider->dim, &src->dim);
+s32 Collider_SetQuadType1(PlayState* play, ColliderQuad* dest, Actor* actor, ColliderQuadInitType1* src) {
+    Collider_SetBaseType1(play, &dest->base, actor, &src->base);
+    Collider_SetElement(play, &dest->elem, &src->elem);
+    Collider_SetQuadDim(play, &dest->dim, &src->dim);
     return true;
 }
 
 /**
  * Sets up the ColliderQuad using the values in src.
  */
-s32 Collider_SetQuad(PlayState* play, ColliderQuad* collider, Actor* actor, ColliderQuadInit* src) {
-    Collider_SetBase(play, &collider->base, actor, &src->base);
-    Collider_SetInfo(play, &collider->info, &src->info);
-    Collider_SetQuadDim(play, &collider->dim, &src->dim);
+s32 Collider_SetQuad(PlayState* play, ColliderQuad* dest, Actor* actor, ColliderQuadInit* src) {
+    Collider_SetBase(play, &dest->base, actor, &src->base);
+    Collider_SetElement(play, &dest->elem, &src->elem);
+    Collider_SetQuadDim(play, &dest->dim, &src->dim);
     return true;
 }
 
 /**
  * Resets the collider's AT collision flags.
  */
-s32 Collider_ResetQuadAT(PlayState* play, Collider* collider) {
-    ColliderQuad* quad = (ColliderQuad*)collider;
+s32 Collider_ResetQuadAT(PlayState* play, Collider* col) {
+    ColliderQuad* quad = (ColliderQuad*)col;
 
     Collider_ResetATBase(play, &quad->base);
-    Collider_ResetATInfo(play, &quad->info);
+    Collider_ResetATElement(play, &quad->elem);
     Collider_ResetQuadACDist(play, &quad->dim);
     return true;
 }
@@ -931,22 +900,22 @@ s32 Collider_ResetQuadAT(PlayState* play, Collider* collider) {
 /**
  * Resets the collider's AC collision flags.
  */
-s32 Collider_ResetQuadAC(PlayState* play, Collider* collider) {
-    ColliderQuad* quad = (ColliderQuad*)collider;
+s32 Collider_ResetQuadAC(PlayState* play, Collider* col) {
+    ColliderQuad* quad = (ColliderQuad*)col;
 
     Collider_ResetACBase(play, &quad->base);
-    Collider_ResetACInfo(play, &quad->info);
+    Collider_ResetACElement(play, &quad->elem);
     return true;
 }
 
 /**
  * Resets the collider's OC collision flags.
  */
-s32 Collider_ResetQuadOC(PlayState* play, Collider* collider) {
-    ColliderQuad* quad = (ColliderQuad*)collider;
+s32 Collider_ResetQuadOC(PlayState* play, Collider* col) {
+    ColliderQuad* quad = (ColliderQuad*)col;
 
     Collider_ResetOCBase(play, &quad->base);
-    Collider_ResetOCInfo(play, &quad->info);
+    Collider_ResetOCElement(play, &quad->elem);
     return true;
 }
 
@@ -958,18 +927,18 @@ s32 Collider_QuadSetNearestAC(PlayState* play, ColliderQuad* quad, Vec3f* hitPos
     f32 acDistSq;
     Vec3f dcMid;
 
-    if (!(quad->info.toucherFlags & TOUCH_NEAREST)) {
+    if (!(quad->elem.toucherFlags & TOUCH_NEAREST)) {
         return true;
     }
     Math_Vec3s_ToVec3f(&dcMid, &quad->dim.dcMid);
     acDistSq = Math3D_Vec3fDistSq(&dcMid, hitPos);
     if (acDistSq < quad->dim.acDistSq) {
         quad->dim.acDistSq = acDistSq;
-        if (quad->info.atHit != NULL) {
-            Collider_ResetACBase(play, quad->info.atHit);
+        if (quad->elem.atHit != NULL) {
+            Collider_ResetACBase(play, quad->elem.atHit);
         }
-        if (quad->info.atHitInfo != NULL) {
-            Collider_ResetACInfo(play, quad->info.atHitInfo);
+        if (quad->elem.atHitElem != NULL) {
+            Collider_ResetACElement(play, quad->elem.atHitElem);
         }
         return true;
     }
@@ -1043,28 +1012,28 @@ void CollisionCheck_DestroyContext(PlayState* play, CollisionCheckContext* colCh
  * Clears all collider lists in CollisionCheckContext when not in SAC mode.
  */
 void CollisionCheck_ClearContext(PlayState* play, CollisionCheckContext* colChkCtx) {
-    Collider** col;
-    OcLine** line;
+    Collider** colP;
+    OcLine** lineP;
 
     if (!(colChkCtx->sacFlags & SAC_ENABLE)) {
         colChkCtx->colATCount = 0;
         colChkCtx->colACCount = 0;
         colChkCtx->colOCCount = 0;
         colChkCtx->colLineCount = 0;
-        for (col = colChkCtx->colAT; col < colChkCtx->colAT + COLLISION_CHECK_AT_MAX; col++) {
-            *col = NULL;
+        for (colP = colChkCtx->colAT; colP < colChkCtx->colAT + COLLISION_CHECK_AT_MAX; colP++) {
+            *colP = NULL;
         }
 
-        for (col = colChkCtx->colAC; col < colChkCtx->colAC + COLLISION_CHECK_AC_MAX; col++) {
-            *col = NULL;
+        for (colP = colChkCtx->colAC; colP < colChkCtx->colAC + COLLISION_CHECK_AC_MAX; colP++) {
+            *colP = NULL;
         }
 
-        for (col = colChkCtx->colOC; col < colChkCtx->colOC + COLLISION_CHECK_OC_MAX; col++) {
-            *col = NULL;
+        for (colP = colChkCtx->colOC; colP < colChkCtx->colOC + COLLISION_CHECK_OC_MAX; colP++) {
+            *colP = NULL;
         }
 
-        for (line = colChkCtx->colLine; line < colChkCtx->colLine + COLLISION_CHECK_OC_LINE_MAX; line++) {
-            *line = NULL;
+        for (lineP = colChkCtx->colLine; lineP < colChkCtx->colLine + COLLISION_CHECK_OC_LINE_MAX; lineP++) {
+            *lineP = NULL;
         }
     }
 }
@@ -1087,36 +1056,39 @@ void CollisionCheck_DisableSAC(PlayState* play, CollisionCheckContext* colChkCtx
  * Draws a collider of any shape.
  * Math3D_DrawSphere and Math3D_DrawCylinder are noops, so JntSph and Cylinder are not drawn.
  */
-void Collider_Draw(PlayState* play, Collider* collider) {
+void Collider_Draw(PlayState* play, Collider* col) {
     ColliderJntSph* jntSph;
-    ColliderCylinder* cylinder;
+    ColliderCylinder* cyl;
     ColliderTris* tris;
     ColliderQuad* quad;
     s32 i;
 
-    if (collider == NULL) {
+    if (col == NULL) {
         return;
     }
-    switch (collider->shape) {
+    switch (col->shape) {
         case COLSHAPE_JNTSPH:
-            jntSph = (ColliderJntSph*)collider;
+            jntSph = (ColliderJntSph*)col;
             for (i = 0; i < jntSph->count; i++) {
                 Math3D_DrawSphere(play, &jntSph->elements[i].dim.worldSphere);
             }
             break;
+
         case COLSHAPE_CYLINDER:
-            cylinder = (ColliderCylinder*)collider;
-            Math3D_DrawCylinder(play, &cylinder->dim);
+            cyl = (ColliderCylinder*)col;
+            Math3D_DrawCylinder(play, &cyl->dim);
             break;
+
         case COLSHAPE_TRIS:
-            tris = (ColliderTris*)collider;
+            tris = (ColliderTris*)col;
             for (i = 0; i < tris->count; i++) {
                 Collider_DrawRedPoly(play->state.gfxCtx, &tris->elements[i].dim.vtx[0], &tris->elements[i].dim.vtx[1],
                                      &tris->elements[i].dim.vtx[2]);
             }
             break;
+
         case COLSHAPE_QUAD:
-            quad = (ColliderQuad*)collider;
+            quad = (ColliderQuad*)col;
             Collider_DrawRedPoly(play->state.gfxCtx, &quad->dim.quad[2], &quad->dim.quad[3], &quad->dim.quad[1]);
             Collider_DrawRedPoly(play->state.gfxCtx, &quad->dim.quad[1], &quad->dim.quad[0], &quad->dim.quad[2]);
             break;
@@ -1128,7 +1100,7 @@ void Collider_Draw(PlayState* play, Collider* collider) {
  * AREG(23) draws OC colliders, AREG(24) draws dynapolys, and AREG(25) draws bg polys
  */
 void CollisionCheck_DrawCollision(PlayState* play, CollisionCheckContext* colChkCtx) {
-    Collider* collider;
+    Collider* col;
     s32 i;
 
     if (AREG(15)) {
@@ -1144,9 +1116,9 @@ void CollisionCheck_DrawCollision(PlayState* play, CollisionCheckContext* colChk
         }
         if (AREG(23)) {
             for (i = 0; i < colChkCtx->colOCCount; i++) {
-                collider = colChkCtx->colOC[i];
-                if (collider->ocFlags1 & OC1_ON) {
-                    Collider_Draw(play, collider);
+                col = colChkCtx->colOC[i];
+                if (col->ocFlags1 & OC1_ON) {
+                    Collider_Draw(play, col);
                 }
             }
         }
@@ -1390,8 +1362,8 @@ s32 CollisionCheck_SetOCLine(PlayState* play, CollisionCheckContext* colChkCtx,
 /**
  * Skips AT elements that are off.
  */
-s32 CollisionCheck_SkipTouch(ColliderInfo* info) {
-    if (!(info->toucherFlags & TOUCH_ON)) {
+s32 CollisionCheck_SkipElementTouch(ColliderElement* elem) {
+    if (!(elem->toucherFlags & TOUCH_ON)) {
         return true;
     }
     return false;
@@ -1400,8 +1372,8 @@ s32 CollisionCheck_SkipTouch(ColliderInfo* info) {
 /**
  * Skips AC elements that are off.
  */
-s32 CollisionCheck_SkipBump(ColliderInfo* info) {
-    if (!(info->bumperFlags & BUMP_ON)) {
+s32 CollisionCheck_SkipElementBump(ColliderElement* elem) {
+    if (!(elem->bumperFlags & BUMP_ON)) {
         return true;
     }
     return false;
@@ -1410,8 +1382,8 @@ s32 CollisionCheck_SkipBump(ColliderInfo* info) {
 /**
  * If the AT element has no dmgFlags in common with the AC element, no collision happens.
  */
-s32 CollisionCheck_NoSharedFlags(ColliderInfo* atInfo, ColliderInfo* acInfo) {
-    if (!(atInfo->toucher.dmgFlags & acInfo->bumper.dmgFlags)) {
+s32 CollisionCheck_NoSharedFlags(ColliderElement* atElem, ColliderElement* acElem) {
+    if (!(atElem->toucher.dmgFlags & acElem->bumper.dmgFlags)) {
         return true;
     }
     return false;
@@ -1558,8 +1530,8 @@ void CollisionCheck_RedBloodUnused(PlayState* play, Collider* collider, Vec3f* v
 /**
  * Plays sound effects and displays hitmarks for solid-type AC colliders (METAL, WOOD, HARD, and TREE)
  */
-void CollisionCheck_HitSolid(PlayState* play, ColliderInfo* info, Collider* collider, Vec3f* hitPos) {
-    s32 flags = info->toucherFlags & TOUCH_SFX_MASK;
+void CollisionCheck_HitSolid(PlayState* play, ColliderElement* elem, Collider* collider, Vec3f* hitPos) {
+    s32 flags = elem->toucherFlags & TOUCH_SFX_MASK;
 
     if (flags == TOUCH_SFX_NORMAL && collider->colType != COLTYPE_METAL) {
         EffectSsHitMark_SpawnFixedScale(play, EFFECT_HITMARK_WHITE, hitPos);
@@ -1601,74 +1573,114 @@ void CollisionCheck_HitSolid(PlayState* play, ColliderInfo* info, Collider* coll
 /**
  * Plays a hit sound effect for AT colliders attached to Player based on the AC element's elemType.
  */
-s32 CollisionCheck_SwordHitAudio(Collider* at, ColliderInfo* acInfo) {
-    if (at->actor != NULL && at->actor->category == ACTORCAT_PLAYER) {
-        if (acInfo->elemType == ELEMTYPE_UNK0) {
-            Audio_PlaySfxGeneral(NA_SE_IT_SWORD_STRIKE, &at->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
+s32 CollisionCheck_SwordHitAudio(Collider* atCol, ColliderElement* acElem) {
+    if (atCol->actor != NULL && atCol->actor->category == ACTORCAT_PLAYER) {
+        if (acElem->elemType == ELEMTYPE_UNK0) {
+            Audio_PlaySfxGeneral(NA_SE_IT_SWORD_STRIKE, &atCol->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
                                  &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
-        } else if (acInfo->elemType == ELEMTYPE_UNK1) {
-            Audio_PlaySfxGeneral(NA_SE_IT_SWORD_STRIKE_HARD, &at->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
+        } else if (acElem->elemType == ELEMTYPE_UNK1) {
+            Audio_PlaySfxGeneral(NA_SE_IT_SWORD_STRIKE_HARD, &atCol->actor->projectedPos, 4,
+                                 &gSfxDefaultFreqAndVolScale, &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
+        } else if (acElem->elemType == ELEMTYPE_UNK2) {
+            Audio_PlaySfxGeneral(NA_SE_NONE, &atCol->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
                                  &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
-        } else if (acInfo->elemType == ELEMTYPE_UNK2) {
-            Audio_PlaySfxGeneral(NA_SE_NONE, &at->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
-                                 &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
-        } else if (acInfo->elemType == ELEMTYPE_UNK3) {
-            Audio_PlaySfxGeneral(NA_SE_NONE, &at->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
+        } else if (acElem->elemType == ELEMTYPE_UNK3) {
+            Audio_PlaySfxGeneral(NA_SE_NONE, &atCol->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
                                  &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
         }
     }
     return true;
 }
 
+typedef struct {
+    /* 0x0 */ u8 blood;
+    /* 0x1 */ u8 effect;
+} HitInfo; // size = 0x2
+
+typedef enum {
+    /* 0 */ BLOOD_NONE,
+    /* 1 */ BLOOD_BLUE,
+    /* 2 */ BLOOD_GREEN,
+    /* 3 */ BLOOD_WATER,
+    /* 4 */ BLOOD_RED,
+    /* 5 */ BLOOD_RED2
+} ColChkBloodType;
+
+typedef enum {
+    /* 0 */ HIT_WHITE,
+    /* 1 */ HIT_DUST,
+    /* 2 */ HIT_RED,
+    /* 3 */ HIT_SOLID,
+    /* 4 */ HIT_WOOD,
+    /* 5 */ HIT_NONE
+} ColChkHitType;
+
+typedef void (*ColChkBloodFunc)(PlayState*, Collider*, Vec3f*);
+
 static ColChkBloodFunc sBloodFuncs[] = {
-    CollisionCheck_NoBlood,    CollisionCheck_BlueBlood, CollisionCheck_GreenBlood,
-    CollisionCheck_WaterBurst, CollisionCheck_RedBlood,  CollisionCheck_RedBloodUnused,
+    CollisionCheck_NoBlood,        // BLOOD_NONE
+    CollisionCheck_BlueBlood,      // BLOOD_BLUE
+    CollisionCheck_GreenBlood,     // BLOOD_GREEN
+    CollisionCheck_WaterBurst,     // BLOOD_WATER
+    CollisionCheck_RedBlood,       // BLOOD_RED
+    CollisionCheck_RedBloodUnused, // BLOOD_RED2
 };
+
 static HitInfo sHitInfo[] = {
-    { BLOOD_BLUE, HIT_WHITE }, { BLOOD_NONE, HIT_DUST },  { BLOOD_GREEN, HIT_DUST },  { BLOOD_NONE, HIT_WHITE },
-    { BLOOD_WATER, HIT_NONE }, { BLOOD_NONE, HIT_RED },   { BLOOD_GREEN, HIT_WHITE }, { BLOOD_RED, HIT_WHITE },
-    { BLOOD_BLUE, HIT_RED },   { BLOOD_NONE, HIT_SOLID }, { BLOOD_NONE, HIT_NONE },   { BLOOD_NONE, HIT_SOLID },
-    { BLOOD_NONE, HIT_SOLID }, { BLOOD_NONE, HIT_WOOD },
+    { BLOOD_BLUE, HIT_WHITE },  // COLTYPE_HIT0
+    { BLOOD_NONE, HIT_DUST },   // COLTYPE_HIT1
+    { BLOOD_GREEN, HIT_DUST },  // COLTYPE_HIT2
+    { BLOOD_NONE, HIT_WHITE },  // COLTYPE_HIT3
+    { BLOOD_WATER, HIT_NONE },  // COLTYPE_HIT4
+    { BLOOD_NONE, HIT_RED },    // COLTYPE_HIT5
+    { BLOOD_GREEN, HIT_WHITE }, // COLTYPE_HIT6
+    { BLOOD_RED, HIT_WHITE },   // COLTYPE_HIT7
+    { BLOOD_BLUE, HIT_RED },    // COLTYPE_HIT8
+    { BLOOD_NONE, HIT_SOLID },  // COLTYPE_METAL
+    { BLOOD_NONE, HIT_NONE },   // COLTYPE_NONE
+    { BLOOD_NONE, HIT_SOLID },  // COLTYPE_WOOD
+    { BLOOD_NONE, HIT_SOLID },  // COLTYPE_HARD
+    { BLOOD_NONE, HIT_WOOD },   // COLTYPE_TREE
 };
 
 /**
  * Handles hitmarks, blood, and sound effects for each AC collision, determined by the AC collider's colType
  */
-void CollisionCheck_HitEffects(PlayState* play, Collider* at, ColliderInfo* atInfo, Collider* ac, ColliderInfo* acInfo,
-                               Vec3f* hitPos) {
-    if (acInfo->bumperFlags & BUMP_NO_HITMARK) {
+void CollisionCheck_HitEffects(PlayState* play, Collider* atCol, ColliderElement* atElem, Collider* acCol,
+                               ColliderElement* acElem, Vec3f* hitPos) {
+    if (acElem->bumperFlags & BUMP_NO_HITMARK) {
         return;
     }
-    if (!(atInfo->toucherFlags & TOUCH_AT_HITMARK) && atInfo->toucherFlags & TOUCH_DREW_HITMARK) {
+    if (!(atElem->toucherFlags & TOUCH_AT_HITMARK) && atElem->toucherFlags & TOUCH_DREW_HITMARK) {
         return;
     }
-    if (ac->actor != NULL) {
-        sBloodFuncs[sHitInfo[ac->colType].blood](play, ac, hitPos);
+    if (acCol->actor != NULL) {
+        sBloodFuncs[sHitInfo[acCol->colType].blood](play, acCol, hitPos);
     }
-    if (ac->actor != NULL) {
-        if (sHitInfo[ac->colType].effect == HIT_SOLID) {
-            CollisionCheck_HitSolid(play, atInfo, ac, hitPos);
-        } else if (sHitInfo[ac->colType].effect == HIT_WOOD) {
-            if (at->actor == NULL) {
+    if (acCol->actor != NULL) {
+        if (sHitInfo[acCol->colType].effect == HIT_SOLID) {
+            CollisionCheck_HitSolid(play, atElem, acCol, hitPos);
+        } else if (sHitInfo[acCol->colType].effect == HIT_WOOD) {
+            if (atCol->actor == NULL) {
                 CollisionCheck_SpawnShieldParticles(play, hitPos);
                 Audio_PlaySfxGeneral(NA_SE_IT_REFLECTION_WOOD, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
                                      &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
             } else {
-                CollisionCheck_SpawnShieldParticlesWood(play, hitPos, &at->actor->projectedPos);
+                CollisionCheck_SpawnShieldParticlesWood(play, hitPos, &atCol->actor->projectedPos);
             }
-        } else if (sHitInfo[ac->colType].effect != HIT_NONE) {
-            EffectSsHitMark_SpawnFixedScale(play, sHitInfo[ac->colType].effect, hitPos);
-            if (!(acInfo->bumperFlags & BUMP_NO_SWORD_SFX)) {
-                CollisionCheck_SwordHitAudio(at, acInfo);
+        } else if (sHitInfo[acCol->colType].effect != HIT_NONE) {
+            EffectSsHitMark_SpawnFixedScale(play, sHitInfo[acCol->colType].effect, hitPos);
+            if (!(acElem->bumperFlags & BUMP_NO_SWORD_SFX)) {
+                CollisionCheck_SwordHitAudio(atCol, acElem);
             }
         }
     } else {
         EffectSsHitMark_SpawnFixedScale(play, EFFECT_HITMARK_WHITE, hitPos);
-        if (ac->actor == NULL) {
+        if (acCol->actor == NULL) {
             Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_BOUND, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
                                  &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
         } else {
-            Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_BOUND, &ac->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
+            Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_BOUND, &acCol->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
                                  &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
         }
     }
@@ -1677,98 +1689,96 @@ void CollisionCheck_HitEffects(PlayState* play, Collider* at, ColliderInfo* atIn
 /**
  * Sets the flags to indicate an attack bounced off an AC_HARD collider.
  */
-void CollisionCheck_SetBounce(Collider* at, Collider* ac) {
-    at->atFlags |= AT_BOUNCED;
-    ac->acFlags |= AC_BOUNCED;
+void CollisionCheck_SetBounce(Collider* atCol, Collider* acCol) {
+    atCol->atFlags |= AT_BOUNCED;
+    acCol->acFlags |= AC_BOUNCED;
 }
 
 /**
  * Performs the AC collision between the AT element and AC element that collided.
  */
-s32 CollisionCheck_SetATvsAC(PlayState* play, Collider* at, ColliderInfo* atInfo, Vec3f* atPos, Collider* ac,
-                             ColliderInfo* acInfo, Vec3f* acPos, Vec3f* hitPos) {
-    if (ac->acFlags & AC_HARD && at->actor != NULL && ac->actor != NULL) {
-        CollisionCheck_SetBounce(at, ac);
+s32 CollisionCheck_SetATvsAC(PlayState* play, Collider* atCol, ColliderElement* atElem, Vec3f* atPos, Collider* acCol,
+                             ColliderElement* acElem, Vec3f* acPos, Vec3f* hitPos) {
+    if (acCol->acFlags & AC_HARD && atCol->actor != NULL && acCol->actor != NULL) {
+        CollisionCheck_SetBounce(atCol, acCol);
     }
-    if (!(acInfo->bumperFlags & BUMP_NO_AT_INFO)) {
-        at->atFlags |= AT_HIT;
-        at->at = ac->actor;
-        atInfo->atHit = ac;
-        atInfo->atHitInfo = acInfo;
-        atInfo->toucherFlags |= TOUCH_HIT;
-        if (at->actor != NULL) {
-            at->actor->colChkInfo.atHitEffect = acInfo->bumper.effect;
+    if (!(acElem->bumperFlags & BUMP_NO_AT_INFO)) {
+        atCol->atFlags |= AT_HIT;
+        atCol->at = acCol->actor;
+        atElem->atHit = acCol;
+        atElem->atHitElem = acElem;
+        atElem->toucherFlags |= TOUCH_HIT;
+        if (atCol->actor != NULL) {
+            atCol->actor->colChkInfo.atHitEffect = acElem->bumper.effect;
         }
     }
-    ac->acFlags |= AC_HIT;
-    ac->ac = at->actor;
-    acInfo->acHit = at;
-    acInfo->acHitInfo = atInfo;
-    acInfo->bumperFlags |= BUMP_HIT;
-    if (ac->actor != NULL) {
-        ac->actor->colChkInfo.acHitEffect = atInfo->toucher.effect;
+    acCol->acFlags |= AC_HIT;
+    acCol->ac = atCol->actor;
+    acElem->acHit = atCol;
+    acElem->acHitElem = atElem;
+    acElem->bumperFlags |= BUMP_HIT;
+    if (acCol->actor != NULL) {
+        acCol->actor->colChkInfo.acHitEffect = atElem->toucher.effect;
     }
-    acInfo->bumper.hitPos.x = hitPos->x;
-    acInfo->bumper.hitPos.y = hitPos->y;
-    acInfo->bumper.hitPos.z = hitPos->z;
-    if (!(atInfo->toucherFlags & TOUCH_AT_HITMARK) && ac->colType != COLTYPE_METAL && ac->colType != COLTYPE_WOOD &&
-        ac->colType != COLTYPE_HARD) {
-        acInfo->bumperFlags |= BUMP_DRAW_HITMARK;
+    acElem->bumper.hitPos.x = hitPos->x;
+    acElem->bumper.hitPos.y = hitPos->y;
+    acElem->bumper.hitPos.z = hitPos->z;
+    if (!(atElem->toucherFlags & TOUCH_AT_HITMARK) && acCol->colType != COLTYPE_METAL &&
+        acCol->colType != COLTYPE_WOOD && acCol->colType != COLTYPE_HARD) {
+        acElem->bumperFlags |= BUMP_DRAW_HITMARK;
     } else {
-        CollisionCheck_HitEffects(play, at, atInfo, ac, acInfo, hitPos);
-        atInfo->toucherFlags |= TOUCH_DREW_HITMARK;
+        CollisionCheck_HitEffects(play, atCol, atElem, acCol, acElem, hitPos);
+        atElem->toucherFlags |= TOUCH_DREW_HITMARK;
     }
     return true;
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_JntSphVsJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT,
-                                      Collider* colAC) {
-    ColliderJntSph* at = (ColliderJntSph*)colAT;
-    ColliderJntSphElement* atItem;
-    ColliderJntSph* ac = (ColliderJntSph*)colAC;
-    ColliderJntSphElement* acElem;
+void CollisionCheck_ATJntSphVsACJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                       Collider* acCol) {
+    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 (atItem = at->elements; atItem < at->elements + at->count; atItem++) {
-            if (CollisionCheck_SkipTouch(&atItem->info) == true) {
+    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_SkipElementTouch(&atJntSphElem->base) == true) {
                 continue;
             }
-            for (acElem = ac->elements; acElem < ac->elements + ac->count; acElem++) {
-                if (CollisionCheck_SkipBump(&acElem->info) == true) {
+            for (acJntSphElem = acJntSph->elements; acJntSphElem < acJntSph->elements + acJntSph->count;
+                 acJntSphElem++) {
+                if (CollisionCheck_SkipElementBump(&acJntSphElem->base) == true) {
                     continue;
                 }
-                if (CollisionCheck_NoSharedFlags(&atItem->info, &acElem->info) == true) {
+                if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acJntSphElem->base) == true) {
                     continue;
                 }
-                if (Math3D_SphVsSphOverlapCenterDist(&atItem->dim.worldSphere, &acElem->dim.worldSphere, &overlapSize,
-                                                     &centerDist) == true) {
+                if (Math3D_SphVsSphOverlapCenterDist(&atJntSphElem->dim.worldSphere, &acJntSphElem->dim.worldSphere,
+                                                     &overlapSize, &centerDist) == true) {
                     f32 acToHit;
                     Vec3f hitPos;
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    atPos.x = atItem->dim.worldSphere.center.x;
-                    atPos.y = atItem->dim.worldSphere.center.y;
-                    atPos.z = atItem->dim.worldSphere.center.z;
-                    acPos.x = acElem->dim.worldSphere.center.x;
-                    acPos.y = acElem->dim.worldSphere.center.y;
-                    acPos.z = acElem->dim.worldSphere.center.z;
+                    atPos.x = atJntSphElem->dim.worldSphere.center.x;
+                    atPos.y = atJntSphElem->dim.worldSphere.center.y;
+                    atPos.z = atJntSphElem->dim.worldSphere.center.z;
+                    acPos.x = acJntSphElem->dim.worldSphere.center.x;
+                    acPos.y = acJntSphElem->dim.worldSphere.center.y;
+                    acPos.z = acJntSphElem->dim.worldSphere.center.z;
                     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, &atItem->info, &atPos, &ac->base, &acElem->info, &acPos,
-                                             &hitPos);
-                    if (!(ac->base.ocFlags2 & OC2_FIRST_ONLY)) {
+                    CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &acJntSph->base,
+                                             &acJntSphElem->base, &acPos, &hitPos);
+                    if (!(acJntSph->base.ocFlags2 & OC2_FIRST_ONLY)) {
                         return;
                     }
                 }
@@ -1777,42 +1787,40 @@ void CollisionCheck_AC_JntSphVsJntSph(PlayState* play, CollisionCheckContext* co
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_JntSphVsCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT,
-                                   Collider* colAC) {
-    ColliderJntSph* at = (ColliderJntSph*)colAT;
-    ColliderJntSphElement* atItem;
-    ColliderCylinder* ac = (ColliderCylinder*)colAC;
+void CollisionCheck_ATJntSphVsACCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                    Collider* acCol) {
+    ColliderJntSph* atJntSph = (ColliderJntSph*)atCol;
+    ColliderJntSphElement* atJntSphElem;
+    ColliderCylinder* acCyl = (ColliderCylinder*)acCol;
     f32 overlapSize;
     f32 centerDist;
 
-    if (at->count > 0 && at->elements != NULL && ac->dim.radius > 0 && ac->dim.height > 0) {
-        if (CollisionCheck_SkipBump(&ac->info) == true) {
+    if (atJntSph->count > 0 && atJntSph->elements != NULL && acCyl->dim.radius > 0 && acCyl->dim.height > 0) {
+        if (CollisionCheck_SkipElementBump(&acCyl->elem) == true) {
             return;
         }
-        for (atItem = at->elements; atItem < at->elements + at->count; atItem++) {
-            if (CollisionCheck_SkipTouch(&atItem->info) == true) {
+        for (atJntSphElem = atJntSph->elements; atJntSphElem < atJntSph->elements + atJntSph->count; atJntSphElem++) {
+            if (CollisionCheck_SkipElementTouch(&atJntSphElem->base) == true) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&atItem->info, &ac->info) == true) {
+            if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acCyl->elem) == true) {
                 continue;
             }
-            if (Math3D_SphVsCylOverlapCenterDist(&atItem->dim.worldSphere, &ac->dim, &overlapSize, &centerDist)) {
+            if (Math3D_SphVsCylOverlapCenterDist(&atJntSphElem->dim.worldSphere, &acCyl->dim, &overlapSize,
+                                                 &centerDist)) {
                 Vec3f hitPos;
                 Vec3f atPos;
                 Vec3f acPos;
                 f32 acToHit;
 
-                atPos.x = atItem->dim.worldSphere.center.x;
-                atPos.y = atItem->dim.worldSphere.center.y;
-                atPos.z = atItem->dim.worldSphere.center.z;
-                acPos.x = ac->dim.pos.x;
-                acPos.y = ac->dim.pos.y;
-                acPos.z = ac->dim.pos.z;
+                atPos.x = atJntSphElem->dim.worldSphere.center.x;
+                atPos.y = atJntSphElem->dim.worldSphere.center.y;
+                atPos.z = atJntSphElem->dim.worldSphere.center.z;
+                acPos.x = acCyl->dim.pos.x;
+                acPos.y = acCyl->dim.pos.y;
+                acPos.z = acCyl->dim.pos.z;
                 if (!IS_ZERO(centerDist)) {
-                    acToHit = ac->dim.radius / centerDist;
+                    acToHit = acCyl->dim.radius / centerDist;
                     if (acToHit <= 1.0f) {
                         hitPos.x = ((atPos.x - acPos.x) * acToHit) + acPos.x;
                         hitPos.y = ((atPos.y - acPos.y) * acToHit) + acPos.y;
@@ -1823,49 +1831,48 @@ void CollisionCheck_AC_JntSphVsCyl(PlayState* play, CollisionCheckContext* colCh
                 } else {
                     Math_Vec3f_Copy(&hitPos, &atPos);
                 }
-                CollisionCheck_SetATvsAC(play, &at->base, &atItem->info, &atPos, &ac->base, &ac->info, &acPos, &hitPos);
+                CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &acCyl->base, &acCyl->elem,
+                                         &acPos, &hitPos);
                 return;
             }
         }
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_CylVsJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT,
-                                   Collider* colAC) {
-    ColliderCylinder* at = (ColliderCylinder*)colAT;
-    ColliderJntSph* ac = (ColliderJntSph*)colAC;
+void CollisionCheck_ATCylVsACJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                    Collider* acCol) {
+    ColliderCylinder* atCyl = (ColliderCylinder*)atCol;
+    ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
     f32 overlapSize;
     f32 centerDist;
-    ColliderJntSphElement* acElem;
+    ColliderJntSphElement* acJntSphElem;
 
-    if (ac->count > 0 && ac->elements != NULL && at->dim.radius > 0 && at->dim.height > 0) {
-        if (CollisionCheck_SkipTouch(&at->info) == true) {
+    if (acJntSph->count > 0 && acJntSph->elements != NULL && atCyl->dim.radius > 0 && atCyl->dim.height > 0) {
+        if (CollisionCheck_SkipElementTouch(&atCyl->elem) == true) {
             return;
         }
-        for (acElem = ac->elements; acElem < ac->elements + ac->count; acElem++) {
-            if (CollisionCheck_SkipBump(&acElem->info) == true) {
+        for (acJntSphElem = acJntSph->elements; acJntSphElem < acJntSph->elements + acJntSph->count; acJntSphElem++) {
+            if (CollisionCheck_SkipElementBump(&acJntSphElem->base) == true) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&at->info, &acElem->info) == true) {
+            if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acJntSphElem->base) == true) {
                 continue;
             }
-            if (Math3D_SphVsCylOverlapCenterDist(&acElem->dim.worldSphere, &at->dim, &overlapSize, &centerDist)) {
+            if (Math3D_SphVsCylOverlapCenterDist(&acJntSphElem->dim.worldSphere, &atCyl->dim, &overlapSize,
+                                                 &centerDist)) {
                 Vec3f hitPos;
                 Vec3f atPos;
                 Vec3f acPos;
                 f32 acToHit;
 
-                atPos.x = at->dim.pos.x;
-                atPos.y = at->dim.pos.y;
-                atPos.z = at->dim.pos.z;
-                acPos.x = acElem->dim.worldSphere.center.x;
-                acPos.y = acElem->dim.worldSphere.center.y;
-                acPos.z = acElem->dim.worldSphere.center.z;
+                atPos.x = atCyl->dim.pos.x;
+                atPos.y = atCyl->dim.pos.y;
+                atPos.z = atCyl->dim.pos.z;
+                acPos.x = acJntSphElem->dim.worldSphere.center.x;
+                acPos.y = acJntSphElem->dim.worldSphere.center.y;
+                acPos.z = acJntSphElem->dim.worldSphere.center.z;
                 if (!IS_ZERO(centerDist)) {
-                    acToHit = acElem->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;
@@ -1876,8 +1883,9 @@ void CollisionCheck_AC_CylVsJntSph(PlayState* play, CollisionCheckContext* colCh
                 } else {
                     Math_Vec3f_Copy(&hitPos, &atPos);
                 }
-                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &ac->base, &acElem->info, &acPos, &hitPos);
-                if (!(ac->base.ocFlags2 & OC2_FIRST_ONLY)) {
+                CollisionCheck_SetATvsAC(play, &atCyl->base, &atCyl->elem, &atPos, &acJntSph->base, &acJntSphElem->base,
+                                         &acPos, &hitPos);
+                if (!(acJntSph->base.ocFlags2 & OC2_FIRST_ONLY)) {
                     break;
                 }
             }
@@ -1885,41 +1893,41 @@ void CollisionCheck_AC_CylVsJntSph(PlayState* play, CollisionCheckContext* colCh
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_JntSphVsTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT,
-                                    Collider* colAC) {
-    ColliderJntSph* at = (ColliderJntSph*)colAT;
-    ColliderJntSphElement* atSph;
-    ColliderTris* ac = (ColliderTris*)colAC;
-    ColliderTrisElement* acTri;
+void CollisionCheck_ATJntSphVsACTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                     Collider* acCol) {
+    ColliderJntSph* atJntSph = (ColliderJntSph*)atCol;
+    ColliderJntSphElement* atJntSphElem;
+    ColliderTris* acTris = (ColliderTris*)acCol;
+    ColliderTrisElement* acTrisElem;
     Vec3f hitPos;
 
-    if (at->count > 0 && at->elements != NULL && ac->count > 0 && ac->elements != NULL) {
-        for (atSph = at->elements; atSph < at->elements + at->count; atSph++) {
-            if (CollisionCheck_SkipTouch(&atSph->info) == true) {
+    if (atJntSph->count > 0 && atJntSph->elements != NULL && acTris->count > 0 && acTris->elements != NULL) {
+        for (atJntSphElem = atJntSph->elements; atJntSphElem < atJntSph->elements + atJntSph->count; atJntSphElem++) {
+            if (CollisionCheck_SkipElementTouch(&atJntSphElem->base) == true) {
                 continue;
             }
-            for (acTri = ac->elements; acTri < ac->elements + ac->count; acTri++) {
-                if (CollisionCheck_SkipBump(&acTri->info) == true) {
+            for (acTrisElem = acTris->elements; acTrisElem < acTris->elements + acTris->count; acTrisElem++) {
+                if (CollisionCheck_SkipElementBump(&acTrisElem->base) == true) {
                     continue;
                 }
-                if (CollisionCheck_NoSharedFlags(&atSph->info, &acTri->info) == true) {
+                if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acTrisElem->base) == true) {
                     continue;
                 }
-                if (Math3D_TriVsSphIntersect(&atSph->dim.worldSphere, &acTri->dim, &hitPos) == true) {
+                if (Math3D_TriVsSphIntersect(&atJntSphElem->dim.worldSphere, &acTrisElem->dim, &hitPos) == true) {
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    atPos.x = atSph->dim.worldSphere.center.x;
-                    atPos.y = atSph->dim.worldSphere.center.y;
-                    atPos.z = atSph->dim.worldSphere.center.z;
-                    acPos.x = (acTri->dim.vtx[0].x + acTri->dim.vtx[1].x + acTri->dim.vtx[2].x) * (1.0f / 3);
-                    acPos.y = (acTri->dim.vtx[0].y + acTri->dim.vtx[1].y + acTri->dim.vtx[2].y) * (1.0f / 3);
-                    acPos.z = (acTri->dim.vtx[0].z + acTri->dim.vtx[1].z + acTri->dim.vtx[2].z) * (1.0f / 3);
-                    CollisionCheck_SetATvsAC(play, &at->base, &atSph->info, &atPos, &ac->base, &acTri->info, &acPos,
-                                             &hitPos);
+                    atPos.x = atJntSphElem->dim.worldSphere.center.x;
+                    atPos.y = atJntSphElem->dim.worldSphere.center.y;
+                    atPos.z = atJntSphElem->dim.worldSphere.center.z;
+                    acPos.x =
+                        (acTrisElem->dim.vtx[0].x + acTrisElem->dim.vtx[1].x + acTrisElem->dim.vtx[2].x) * (1.0f / 3);
+                    acPos.y =
+                        (acTrisElem->dim.vtx[0].y + acTrisElem->dim.vtx[1].y + acTrisElem->dim.vtx[2].y) * (1.0f / 3);
+                    acPos.z =
+                        (acTrisElem->dim.vtx[0].z + acTrisElem->dim.vtx[1].z + acTrisElem->dim.vtx[2].z) * (1.0f / 3);
+                    CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &acTris->base,
+                                             &acTrisElem->base, &acPos, &hitPos);
                     return;
                 }
             }
@@ -1927,40 +1935,40 @@ void CollisionCheck_AC_JntSphVsTris(PlayState* play, CollisionCheckContext* colC
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_TrisVsJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT,
-                                    Collider* colAC) {
-    ColliderTris* at = (ColliderTris*)colAT;
-    ColliderTrisElement* atItem;
-    ColliderJntSph* ac = (ColliderJntSph*)colAC;
-    ColliderJntSphElement* acElem;
+void CollisionCheck_ATTrisVsACJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                     Collider* acCol) {
+    ColliderTris* atTris = (ColliderTris*)atCol;
+    ColliderTrisElement* atTrisElem;
+    ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
+    ColliderJntSphElement* acJntSphElem;
     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) == true) {
+    if (acJntSph->count > 0 && acJntSph->elements != NULL && atTris->count > 0 && atTris->elements != NULL) {
+        for (acJntSphElem = acJntSph->elements; acJntSphElem < acJntSph->elements + acJntSph->count; acJntSphElem++) {
+            if (CollisionCheck_SkipElementBump(&acJntSphElem->base) == true) {
                 continue;
             }
-            for (atItem = at->elements; atItem < at->elements + at->count; atItem++) {
-                if (CollisionCheck_SkipTouch(&atItem->info) == true) {
+            for (atTrisElem = atTris->elements; atTrisElem < atTris->elements + atTris->count; atTrisElem++) {
+                if (CollisionCheck_SkipElementTouch(&atTrisElem->base) == true) {
                     continue;
                 }
-                if (CollisionCheck_NoSharedFlags(&atItem->info, &acElem->info) == true) {
+                if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acJntSphElem->base) == true) {
                     continue;
                 }
-                if (Math3D_TriVsSphIntersect(&acElem->dim.worldSphere, &atItem->dim, &hitPos) == true) {
+                if (Math3D_TriVsSphIntersect(&acJntSphElem->dim.worldSphere, &atTrisElem->dim, &hitPos) == true) {
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    Math_Vec3s_ToVec3f(&acPos, &acElem->dim.worldSphere.center);
-                    atPos.x = (atItem->dim.vtx[0].x + atItem->dim.vtx[1].x + atItem->dim.vtx[2].x) * (1.0f / 3);
-                    atPos.y = (atItem->dim.vtx[0].y + atItem->dim.vtx[1].y + atItem->dim.vtx[2].y) * (1.0f / 3);
-                    atPos.z = (atItem->dim.vtx[0].z + atItem->dim.vtx[1].z + atItem->dim.vtx[2].z) * (1.0f / 3);
-                    CollisionCheck_SetATvsAC(play, &at->base, &atItem->info, &atPos, &ac->base, &acElem->info, &acPos,
-                                             &hitPos);
-                    if (!(ac->base.ocFlags2 & OC2_FIRST_ONLY)) {
+                    Math_Vec3s_ToVec3f(&acPos, &acJntSphElem->dim.worldSphere.center);
+                    atPos.x =
+                        (atTrisElem->dim.vtx[0].x + atTrisElem->dim.vtx[1].x + atTrisElem->dim.vtx[2].x) * (1.0f / 3);
+                    atPos.y =
+                        (atTrisElem->dim.vtx[0].y + atTrisElem->dim.vtx[1].y + atTrisElem->dim.vtx[2].y) * (1.0f / 3);
+                    atPos.z =
+                        (atTrisElem->dim.vtx[0].z + atTrisElem->dim.vtx[1].z + atTrisElem->dim.vtx[2].z) * (1.0f / 3);
+                    CollisionCheck_SetATvsAC(play, &atTris->base, &atTrisElem->base, &atPos, &acJntSph->base,
+                                             &acJntSphElem->base, &acPos, &hitPos);
+                    if (!(acJntSph->base.ocFlags2 & OC2_FIRST_ONLY)) {
                         return;
                     }
                 }
@@ -1969,93 +1977,97 @@ void CollisionCheck_AC_TrisVsJntSph(PlayState* play, CollisionCheckContext* colC
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_JntSphVsQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT,
-                                    Collider* colAC) {
+void CollisionCheck_ATJntSphVsACQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                     Collider* acCol) {
     static TriNorm tri1;
     static TriNorm tri2;
-    ColliderJntSph* at = (ColliderJntSph*)colAT;
-    ColliderQuad* ac = (ColliderQuad*)colAC;
+    ColliderJntSph* atJntSph = (ColliderJntSph*)atCol;
+    ColliderQuad* acQuad = (ColliderQuad*)acCol;
     Vec3f hitPos;
-    ColliderJntSphElement* atItem;
+    ColliderJntSphElement* atJntSphElem;
 
-    if (at->count > 0 && at->elements != NULL) {
-        if (CollisionCheck_SkipBump(&ac->info) == true) {
+    if (atJntSph->count > 0 && atJntSph->elements != NULL) {
+        if (CollisionCheck_SkipElementBump(&acQuad->elem) == true) {
             return;
         }
-        Math3D_TriNorm(&tri1, &ac->dim.quad[2], &ac->dim.quad[3], &ac->dim.quad[1]);
-        Math3D_TriNorm(&tri2, &ac->dim.quad[1], &ac->dim.quad[0], &ac->dim.quad[2]);
-        for (atItem = at->elements; atItem < at->elements + at->count; atItem++) {
-            if (CollisionCheck_SkipTouch(&atItem->info) == true) {
+        Math3D_TriNorm(&tri1, &acQuad->dim.quad[2], &acQuad->dim.quad[3], &acQuad->dim.quad[1]);
+        Math3D_TriNorm(&tri2, &acQuad->dim.quad[1], &acQuad->dim.quad[0], &acQuad->dim.quad[2]);
+        for (atJntSphElem = atJntSph->elements; atJntSphElem < atJntSph->elements + atJntSph->count; atJntSphElem++) {
+            if (CollisionCheck_SkipElementTouch(&atJntSphElem->base) == true) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&atItem->info, &ac->info) == true) {
+            if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acQuad->elem) == true) {
                 continue;
             }
-            if (Math3D_TriVsSphIntersect(&atItem->dim.worldSphere, &tri1, &hitPos) == true ||
-                Math3D_TriVsSphIntersect(&atItem->dim.worldSphere, &tri2, &hitPos) == true) {
+            if (Math3D_TriVsSphIntersect(&atJntSphElem->dim.worldSphere, &tri1, &hitPos) == true ||
+                Math3D_TriVsSphIntersect(&atJntSphElem->dim.worldSphere, &tri2, &hitPos) == true) {
                 Vec3f atPos;
                 Vec3f acPos;
 
-                Math_Vec3s_ToVec3f(&atPos, &atItem->dim.worldSphere.center);
+                Math_Vec3s_ToVec3f(&atPos, &atJntSphElem->dim.worldSphere.center);
 
-                acPos.x = (ac->dim.quad[0].x + (ac->dim.quad[1].x + (ac->dim.quad[3].x + ac->dim.quad[2].x))) / 4.0f;
-                acPos.y = (ac->dim.quad[0].y + (ac->dim.quad[1].y + (ac->dim.quad[3].y + ac->dim.quad[2].y))) / 4.0f;
-                acPos.z = (ac->dim.quad[0].z + (ac->dim.quad[1].z + (ac->dim.quad[3].z + ac->dim.quad[2].z))) / 4.0f;
+                acPos.x = (acQuad->dim.quad[0].x +
+                           (acQuad->dim.quad[1].x + (acQuad->dim.quad[3].x + acQuad->dim.quad[2].x))) /
+                          4.0f;
+                acPos.y = (acQuad->dim.quad[0].y +
+                           (acQuad->dim.quad[1].y + (acQuad->dim.quad[3].y + acQuad->dim.quad[2].y))) /
+                          4.0f;
+                acPos.z = (acQuad->dim.quad[0].z +
+                           (acQuad->dim.quad[1].z + (acQuad->dim.quad[3].z + acQuad->dim.quad[2].z))) /
+                          4.0f;
 
-                CollisionCheck_SetATvsAC(play, &at->base, &atItem->info, &atPos, &ac->base, &ac->info, &acPos, &hitPos);
+                CollisionCheck_SetATvsAC(play, &atJntSph->base, &atJntSphElem->base, &atPos, &acQuad->base,
+                                         &acQuad->elem, &acPos, &hitPos);
                 return;
             }
         }
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_QuadVsJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT,
-                                    Collider* colAC) {
+void CollisionCheck_ATQuadVsACJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                     Collider* acCol) {
     static TriNorm tri1;
     static TriNorm tri2;
-    ColliderJntSph* ac = (ColliderJntSph*)colAC;
+    ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
     Vec3f hitPos;
-    ColliderQuad* at = (ColliderQuad*)colAT;
-    ColliderJntSphElement* acElem;
+    ColliderQuad* atQuad = (ColliderQuad*)atCol;
+    ColliderJntSphElement* acJntSphElem;
 
-    if (ac->count > 0 && ac->elements != NULL) {
-        if (CollisionCheck_SkipTouch(&at->info) == true) {
+    if (acJntSph->count > 0 && acJntSph->elements != NULL) {
+        if (CollisionCheck_SkipElementTouch(&atQuad->elem) == true) {
             return;
         }
-        Math3D_TriNorm(&tri1, &at->dim.quad[2], &at->dim.quad[3], &at->dim.quad[1]);
-        Math3D_TriNorm(&tri2, &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) == true) {
+        Math3D_TriNorm(&tri1, &atQuad->dim.quad[2], &atQuad->dim.quad[3], &atQuad->dim.quad[1]);
+        Math3D_TriNorm(&tri2, &atQuad->dim.quad[2], &atQuad->dim.quad[1], &atQuad->dim.quad[0]);
+        for (acJntSphElem = acJntSph->elements; acJntSphElem < acJntSph->elements + acJntSph->count; acJntSphElem++) {
+            if (CollisionCheck_SkipElementBump(&acJntSphElem->base) == true) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&at->info, &acElem->info) == true) {
+            if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acJntSphElem->base) == true) {
                 continue;
             }
-            if (Math3D_TriVsSphIntersect(&acElem->dim.worldSphere, &tri1, &hitPos) == true ||
-                Math3D_TriVsSphIntersect(&acElem->dim.worldSphere, &tri2, &hitPos) == true) {
-                if (Collider_QuadSetNearestAC(play, at, &hitPos)) {
+            if (Math3D_TriVsSphIntersect(&acJntSphElem->dim.worldSphere, &tri1, &hitPos) == true ||
+                Math3D_TriVsSphIntersect(&acJntSphElem->dim.worldSphere, &tri2, &hitPos) == true) {
+                if (Collider_QuadSetNearestAC(play, atQuad, &hitPos)) {
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    acPos.x = acElem->dim.worldSphere.center.x;
-                    acPos.y = acElem->dim.worldSphere.center.y;
-                    acPos.z = acElem->dim.worldSphere.center.z;
+                    acPos.x = acJntSphElem->dim.worldSphere.center.x;
+                    acPos.y = acJntSphElem->dim.worldSphere.center.y;
+                    acPos.z = acJntSphElem->dim.worldSphere.center.z;
 
-                    atPos.x =
-                        (at->dim.quad[0].x + (at->dim.quad[1].x + (at->dim.quad[3].x + at->dim.quad[2].x))) / 4.0f;
-                    atPos.y =
-                        (at->dim.quad[0].y + (at->dim.quad[1].y + (at->dim.quad[3].y + at->dim.quad[2].y))) / 4.0f;
-                    atPos.z =
-                        (at->dim.quad[0].z + (at->dim.quad[1].z + (at->dim.quad[3].z + at->dim.quad[2].z))) / 4.0f;
-                    CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &ac->base, &acElem->info, &acPos,
-                                             &hitPos);
-                    if (!(ac->base.ocFlags2 & OC2_FIRST_ONLY)) {
+                    atPos.x = (atQuad->dim.quad[0].x +
+                               (atQuad->dim.quad[1].x + (atQuad->dim.quad[3].x + atQuad->dim.quad[2].x))) /
+                              4.0f;
+                    atPos.y = (atQuad->dim.quad[0].y +
+                               (atQuad->dim.quad[1].y + (atQuad->dim.quad[3].y + atQuad->dim.quad[2].y))) /
+                              4.0f;
+                    atPos.z = (atQuad->dim.quad[0].z +
+                               (atQuad->dim.quad[1].z + (atQuad->dim.quad[3].z + atQuad->dim.quad[2].z))) /
+                              4.0f;
+                    CollisionCheck_SetATvsAC(play, &atQuad->base, &atQuad->elem, &atPos, &acJntSph->base,
+                                             &acJntSphElem->base, &acPos, &hitPos);
+                    if (!(acJntSph->base.ocFlags2 & OC2_FIRST_ONLY)) {
                         return;
                     }
                 }
@@ -2064,154 +2076,160 @@ void CollisionCheck_AC_QuadVsJntSph(PlayState* play, CollisionCheckContext* colC
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_CylVsCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
-    ColliderCylinder* at = (ColliderCylinder*)colAT;
-    ColliderCylinder* ac = (ColliderCylinder*)colAC;
+void CollisionCheck_ATCylVsACCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol, Collider* acCol) {
+    ColliderCylinder* atCyl = (ColliderCylinder*)atCol;
+    ColliderCylinder* acCyl = (ColliderCylinder*)acCol;
     f32 overlapSize;
     f32 centerDist;
     Vec3f hitPos;
 
-    if (at->dim.radius > 0 && at->dim.height > 0 && ac->dim.radius > 0 && ac->dim.height > 0) {
-        if (CollisionCheck_SkipBump(&ac->info) == true) {
+    if (atCyl->dim.radius > 0 && atCyl->dim.height > 0 && acCyl->dim.radius > 0 && acCyl->dim.height > 0) {
+        if (CollisionCheck_SkipElementBump(&acCyl->elem) == true) {
             return;
         }
-        if (CollisionCheck_SkipTouch(&at->info) == true) {
+        if (CollisionCheck_SkipElementTouch(&atCyl->elem) == true) {
             return;
         }
-        if (CollisionCheck_NoSharedFlags(&at->info, &ac->info) == true) {
+        if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acCyl->elem) == true) {
             return;
         }
-        if (Math3D_CylVsCylOverlapCenterDist(&at->dim, &ac->dim, &overlapSize, &centerDist) == true) {
+        if (Math3D_CylVsCylOverlapCenterDist(&atCyl->dim, &acCyl->dim, &overlapSize, &centerDist) == true) {
             Vec3f atPos;
             Vec3f acPos;
             f32 acToHit;
 
-            Math_Vec3s_ToVec3f(&atPos, &at->dim.pos);
-            Math_Vec3s_ToVec3f(&acPos, &ac->dim.pos);
+            Math_Vec3s_ToVec3f(&atPos, &atCyl->dim.pos);
+            Math_Vec3s_ToVec3f(&acPos, &acCyl->dim.pos);
             if (!IS_ZERO(centerDist)) {
-                acToHit = ac->dim.radius / centerDist;
-                hitPos.y = (f32)ac->dim.pos.y + ac->dim.yShift + ac->dim.height * 0.5f;
-                hitPos.x = ((f32)at->dim.pos.x - ac->dim.pos.x) * acToHit + ac->dim.pos.x;
-                hitPos.z = ((f32)at->dim.pos.z - ac->dim.pos.z) * acToHit + ac->dim.pos.z;
+                acToHit = acCyl->dim.radius / centerDist;
+                hitPos.y = (f32)acCyl->dim.pos.y + acCyl->dim.yShift + acCyl->dim.height * 0.5f;
+                hitPos.x = ((f32)atCyl->dim.pos.x - acCyl->dim.pos.x) * acToHit + acCyl->dim.pos.x;
+                hitPos.z = ((f32)atCyl->dim.pos.z - acCyl->dim.pos.z) * acToHit + acCyl->dim.pos.z;
             } else {
-                Math_Vec3s_ToVec3f(&hitPos, &ac->dim.pos);
+                Math_Vec3s_ToVec3f(&hitPos, &acCyl->dim.pos);
             }
-            CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &ac->base, &ac->info, &acPos, &hitPos);
+            CollisionCheck_SetATvsAC(play, &atCyl->base, &atCyl->elem, &atPos, &acCyl->base, &acCyl->elem, &acPos,
+                                     &hitPos);
         }
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_CylVsTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
-    ColliderCylinder* at = (ColliderCylinder*)colAT;
-    ColliderTris* ac = (ColliderTris*)colAC;
-    ColliderTrisElement* acElem;
+void CollisionCheck_ATCylVsACTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol, Collider* acCol) {
+    ColliderCylinder* atCyl = (ColliderCylinder*)atCol;
+    ColliderTris* acTris = (ColliderTris*)acCol;
+    ColliderTrisElement* acTrisElem;
     Vec3f hitPos;
 
-    if (at->dim.radius > 0 && at->dim.height > 0 && ac->count > 0 && ac->elements != NULL) {
-        if (CollisionCheck_SkipTouch(&at->info) == true) {
+    if (atCyl->dim.radius > 0 && atCyl->dim.height > 0 && acTris->count > 0 && acTris->elements != NULL) {
+        if (CollisionCheck_SkipElementTouch(&atCyl->elem) == true) {
             return;
         }
-        for (acElem = ac->elements; acElem < ac->elements + ac->count; acElem++) {
-            if (CollisionCheck_SkipBump(&acElem->info) == true) {
+        for (acTrisElem = acTris->elements; acTrisElem < acTris->elements + acTris->count; acTrisElem++) {
+            if (CollisionCheck_SkipElementBump(&acTrisElem->base) == true) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&at->info, &acElem->info) == true) {
+            if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acTrisElem->base) == true) {
                 continue;
             }
-            if (Math3D_CylTriVsIntersect(&at->dim, &acElem->dim, &hitPos) == true) {
-                Vec3f atpos;
+            if (Math3D_CylTriVsIntersect(&atCyl->dim, &acTrisElem->dim, &hitPos) == true) {
+                Vec3f atPos;
                 Vec3f acPos;
 
-                Math_Vec3s_ToVec3f(&atpos, &at->dim.pos);
+                Math_Vec3s_ToVec3f(&atPos, &atCyl->dim.pos);
 
-                acPos.x = (acElem->dim.vtx[0].x + acElem->dim.vtx[1].x + acElem->dim.vtx[2].x) * (1.0f / 3);
-                acPos.y = (acElem->dim.vtx[0].y + acElem->dim.vtx[1].y + acElem->dim.vtx[2].y) * (1.0f / 3);
-                acPos.z = (acElem->dim.vtx[0].z + acElem->dim.vtx[1].z + acElem->dim.vtx[2].z) * (1.0f / 3);
-                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atpos, &ac->base, &acElem->info, &acPos, &hitPos);
+                acPos.x = (acTrisElem->dim.vtx[0].x + acTrisElem->dim.vtx[1].x + acTrisElem->dim.vtx[2].x) * (1.0f / 3);
+                acPos.y = (acTrisElem->dim.vtx[0].y + acTrisElem->dim.vtx[1].y + acTrisElem->dim.vtx[2].y) * (1.0f / 3);
+                acPos.z = (acTrisElem->dim.vtx[0].z + acTrisElem->dim.vtx[1].z + acTrisElem->dim.vtx[2].z) * (1.0f / 3);
+                CollisionCheck_SetATvsAC(play, &atCyl->base, &atCyl->elem, &atPos, &acTris->base, &acTrisElem->base,
+                                         &acPos, &hitPos);
                 return;
             }
         }
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_TrisVsCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
+void CollisionCheck_ATTrisVsACCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol, Collider* acCol) {
     static Vec3f hitPos;
-    ColliderTris* at = (ColliderTris*)colAT;
-    ColliderTrisElement* atItem;
-    ColliderCylinder* ac = (ColliderCylinder*)colAC;
+    ColliderTris* atTris = (ColliderTris*)atCol;
+    ColliderTrisElement* atTrisElem;
+    ColliderCylinder* acCyl = (ColliderCylinder*)acCol;
     Vec3f atPos;
     Vec3f acPos;
 
-    if (ac->dim.radius > 0 && ac->dim.height > 0 && at->count > 0 && at->elements != NULL) {
-        if (CollisionCheck_SkipBump(&ac->info) == true) {
+    if (acCyl->dim.radius > 0 && acCyl->dim.height > 0 && atTris->count > 0 && atTris->elements != NULL) {
+        if (CollisionCheck_SkipElementBump(&acCyl->elem) == true) {
             return;
         }
-        for (atItem = at->elements; atItem < at->elements + at->count; atItem++) {
-            if (CollisionCheck_SkipTouch(&atItem->info) == true) {
+        for (atTrisElem = atTris->elements; atTrisElem < atTris->elements + atTris->count; atTrisElem++) {
+            if (CollisionCheck_SkipElementTouch(&atTrisElem->base) == true) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&atItem->info, &ac->info) == true) {
+            if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acCyl->elem) == true) {
                 continue;
             }
 
-            if (Math3D_CylTriVsIntersect(&ac->dim, &atItem->dim, &hitPos) == true) {
-                atPos.x = (atItem->dim.vtx[0].x + atItem->dim.vtx[1].x + atItem->dim.vtx[2].x) * (1.0f / 3);
-                atPos.y = (atItem->dim.vtx[0].y + atItem->dim.vtx[1].y + atItem->dim.vtx[2].y) * (1.0f / 3);
-                atPos.z = (atItem->dim.vtx[0].z + atItem->dim.vtx[1].z + atItem->dim.vtx[2].z) * (1.0f / 3);
-                Math_Vec3s_ToVec3f(&acPos, &ac->dim.pos);
-                CollisionCheck_SetATvsAC(play, &at->base, &atItem->info, &atPos, &ac->base, &ac->info, &acPos, &hitPos);
+            if (Math3D_CylTriVsIntersect(&acCyl->dim, &atTrisElem->dim, &hitPos) == true) {
+                atPos.x = (atTrisElem->dim.vtx[0].x + atTrisElem->dim.vtx[1].x + atTrisElem->dim.vtx[2].x) * (1.0f / 3);
+                atPos.y = (atTrisElem->dim.vtx[0].y + atTrisElem->dim.vtx[1].y + atTrisElem->dim.vtx[2].y) * (1.0f / 3);
+                atPos.z = (atTrisElem->dim.vtx[0].z + atTrisElem->dim.vtx[1].z + atTrisElem->dim.vtx[2].z) * (1.0f / 3);
+                Math_Vec3s_ToVec3f(&acPos, &acCyl->dim.pos);
+                CollisionCheck_SetATvsAC(play, &atTris->base, &atTrisElem->base, &atPos, &acCyl->base, &acCyl->elem,
+                                         &acPos, &hitPos);
                 return;
             }
         }
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_CylVsQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
+void CollisionCheck_ATCylVsACQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol, Collider* acCol) {
     static TriNorm tri1;
     static TriNorm tri2;
     static Vec3f hitPos;
-    ColliderCylinder* at = (ColliderCylinder*)colAT;
-    ColliderQuad* ac = (ColliderQuad*)colAC;
+    ColliderCylinder* atCyl = (ColliderCylinder*)atCol;
+    ColliderQuad* acQuad = (ColliderQuad*)acCol;
 
-    if (at->dim.height > 0 && at->dim.radius > 0) {
-        if (CollisionCheck_SkipTouch(&at->info) == true || CollisionCheck_SkipBump(&ac->info) == true) {
+    if (atCyl->dim.height > 0 && atCyl->dim.radius > 0) {
+        if (CollisionCheck_SkipElementTouch(&atCyl->elem) == true ||
+            CollisionCheck_SkipElementBump(&acQuad->elem) == true) {
             return;
         }
-        if (CollisionCheck_NoSharedFlags(&at->info, &ac->info) == true) {
+        if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acQuad->elem) == true) {
             return;
         }
-        Math3D_TriNorm(&tri1, &ac->dim.quad[2], &ac->dim.quad[3], &ac->dim.quad[1]);
-        Math3D_TriNorm(&tri2, &ac->dim.quad[1], &ac->dim.quad[0], &ac->dim.quad[2]);
-        if (Math3D_CylTriVsIntersect(&at->dim, &tri1, &hitPos) == true) {
+        Math3D_TriNorm(&tri1, &acQuad->dim.quad[2], &acQuad->dim.quad[3], &acQuad->dim.quad[1]);
+        Math3D_TriNorm(&tri2, &acQuad->dim.quad[1], &acQuad->dim.quad[0], &acQuad->dim.quad[2]);
+        if (Math3D_CylTriVsIntersect(&atCyl->dim, &tri1, &hitPos) == true) {
             Vec3f atPos1;
             Vec3f acPos1;
 
-            Math_Vec3s_ToVec3f(&atPos1, &at->dim.pos);
-            acPos1.x = (ac->dim.quad[0].x + (ac->dim.quad[1].x + (ac->dim.quad[3].x + ac->dim.quad[2].x))) / 4.0f;
-            acPos1.y = (ac->dim.quad[0].y + (ac->dim.quad[1].y + (ac->dim.quad[3].y + ac->dim.quad[2].y))) / 4.0f;
-            acPos1.z = (ac->dim.quad[0].z + (ac->dim.quad[1].z + (ac->dim.quad[3].z + ac->dim.quad[2].z))) / 4.0f;
-            CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos1, &ac->base, &ac->info, &acPos1, &hitPos);
-        } else if (Math3D_CylTriVsIntersect(&at->dim, &tri2, &hitPos) == true) {
+            Math_Vec3s_ToVec3f(&atPos1, &atCyl->dim.pos);
+            acPos1.x =
+                (acQuad->dim.quad[0].x + (acQuad->dim.quad[1].x + (acQuad->dim.quad[3].x + acQuad->dim.quad[2].x))) /
+                4.0f;
+            acPos1.y =
+                (acQuad->dim.quad[0].y + (acQuad->dim.quad[1].y + (acQuad->dim.quad[3].y + acQuad->dim.quad[2].y))) /
+                4.0f;
+            acPos1.z =
+                (acQuad->dim.quad[0].z + (acQuad->dim.quad[1].z + (acQuad->dim.quad[3].z + acQuad->dim.quad[2].z))) /
+                4.0f;
+            CollisionCheck_SetATvsAC(play, &atCyl->base, &atCyl->elem, &atPos1, &acQuad->base, &acQuad->elem, &acPos1,
+                                     &hitPos);
+        } else if (Math3D_CylTriVsIntersect(&atCyl->dim, &tri2, &hitPos) == true) {
             Vec3f atPos2;
             Vec3f acPos2;
 
-            Math_Vec3s_ToVec3f(&atPos2, &at->dim.pos);
-            acPos2.x = (ac->dim.quad[0].x + (ac->dim.quad[1].x + (ac->dim.quad[3].x + ac->dim.quad[2].x))) / 4.0f;
-            acPos2.y = (ac->dim.quad[0].y + (ac->dim.quad[1].y + (ac->dim.quad[3].y + ac->dim.quad[2].y))) / 4.0f;
-            acPos2.z = (ac->dim.quad[0].z + (ac->dim.quad[1].z + (ac->dim.quad[3].z + ac->dim.quad[2].z))) / 4.0f;
-            CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos2, &ac->base, &ac->info, &acPos2, &hitPos);
+            Math_Vec3s_ToVec3f(&atPos2, &atCyl->dim.pos);
+            acPos2.x =
+                (acQuad->dim.quad[0].x + (acQuad->dim.quad[1].x + (acQuad->dim.quad[3].x + acQuad->dim.quad[2].x))) /
+                4.0f;
+            acPos2.y =
+                (acQuad->dim.quad[0].y + (acQuad->dim.quad[1].y + (acQuad->dim.quad[3].y + acQuad->dim.quad[2].y))) /
+                4.0f;
+            acPos2.z =
+                (acQuad->dim.quad[0].z + (acQuad->dim.quad[1].z + (acQuad->dim.quad[3].z + acQuad->dim.quad[2].z))) /
+                4.0f;
+            CollisionCheck_SetATvsAC(play, &atCyl->base, &atCyl->elem, &atPos2, &acQuad->base, &acQuad->elem, &acPos2,
+                                     &hitPos);
         }
     }
 }
@@ -2219,48 +2237,60 @@ void CollisionCheck_AC_CylVsQuad(PlayState* play, CollisionCheckContext* colChkC
 static s8 sBssDummy0;
 static s8 sBssDummy1;
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_QuadVsCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
+void CollisionCheck_ATQuadVsACCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol, Collider* acCol) {
     static TriNorm tri1;
     static TriNorm tri2;
     static Vec3f hitPos;
-    ColliderQuad* at = (ColliderQuad*)colAT;
-    ColliderCylinder* ac = (ColliderCylinder*)colAC;
+    ColliderQuad* atQuad = (ColliderQuad*)atCol;
+    ColliderCylinder* acCyl = (ColliderCylinder*)acCol;
 
-    if (ac->dim.height > 0 && ac->dim.radius > 0) {
-        if (CollisionCheck_SkipBump(&ac->info) == true || CollisionCheck_SkipTouch(&at->info) == true) {
+    if (acCyl->dim.height > 0 && acCyl->dim.radius > 0) {
+        if (CollisionCheck_SkipElementBump(&acCyl->elem) == true ||
+            CollisionCheck_SkipElementTouch(&atQuad->elem) == true) {
             return;
         }
-        if (CollisionCheck_NoSharedFlags(&at->info, &ac->info) == true) {
+        if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acCyl->elem) == true) {
             return;
         }
-        Math3D_TriNorm(&tri1, &at->dim.quad[2], &at->dim.quad[3], &at->dim.quad[1]);
-        Math3D_TriNorm(&tri2, &at->dim.quad[2], &at->dim.quad[1], &at->dim.quad[0]);
-        if (Math3D_CylTriVsIntersect(&ac->dim, &tri1, &hitPos) == true) {
-            if (Collider_QuadSetNearestAC(play, at, &hitPos)) {
+        Math3D_TriNorm(&tri1, &atQuad->dim.quad[2], &atQuad->dim.quad[3], &atQuad->dim.quad[1]);
+        Math3D_TriNorm(&tri2, &atQuad->dim.quad[2], &atQuad->dim.quad[1], &atQuad->dim.quad[0]);
+        if (Math3D_CylTriVsIntersect(&acCyl->dim, &tri1, &hitPos) == true) {
+            if (Collider_QuadSetNearestAC(play, atQuad, &hitPos)) {
                 Vec3f atPos1;
                 Vec3f acPos1;
 
-                atPos1.x = (at->dim.quad[0].x + (at->dim.quad[1].x + (at->dim.quad[3].x + at->dim.quad[2].x))) / 4.0f;
-                atPos1.y = (at->dim.quad[0].y + (at->dim.quad[1].y + (at->dim.quad[3].y + at->dim.quad[2].y))) / 4.0f;
-                atPos1.z = (at->dim.quad[0].z + (at->dim.quad[1].z + (at->dim.quad[3].z + at->dim.quad[2].z))) / 4.0f;
-                Math_Vec3s_ToVec3f(&acPos1, &ac->dim.pos);
-                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos1, &ac->base, &ac->info, &acPos1, &hitPos);
+                atPos1.x = (atQuad->dim.quad[0].x +
+                            (atQuad->dim.quad[1].x + (atQuad->dim.quad[3].x + atQuad->dim.quad[2].x))) /
+                           4.0f;
+                atPos1.y = (atQuad->dim.quad[0].y +
+                            (atQuad->dim.quad[1].y + (atQuad->dim.quad[3].y + atQuad->dim.quad[2].y))) /
+                           4.0f;
+                atPos1.z = (atQuad->dim.quad[0].z +
+                            (atQuad->dim.quad[1].z + (atQuad->dim.quad[3].z + atQuad->dim.quad[2].z))) /
+                           4.0f;
+                Math_Vec3s_ToVec3f(&acPos1, &acCyl->dim.pos);
+                CollisionCheck_SetATvsAC(play, &atQuad->base, &atQuad->elem, &atPos1, &acCyl->base, &acCyl->elem,
+                                         &acPos1, &hitPos);
                 return;
             }
         }
-        if (Math3D_CylTriVsIntersect(&ac->dim, &tri2, &hitPos) == true) {
-            if (Collider_QuadSetNearestAC(play, at, &hitPos)) {
+        if (Math3D_CylTriVsIntersect(&acCyl->dim, &tri2, &hitPos) == true) {
+            if (Collider_QuadSetNearestAC(play, atQuad, &hitPos)) {
                 Vec3f atPos2;
                 Vec3f acPos2;
 
-                atPos2.x = (at->dim.quad[0].x + (at->dim.quad[1].x + (at->dim.quad[3].x + at->dim.quad[2].x))) / 4.0f;
-                atPos2.y = (at->dim.quad[0].y + (at->dim.quad[1].y + (at->dim.quad[3].y + at->dim.quad[2].y))) / 4.0f;
-                atPos2.z = (at->dim.quad[0].z + (at->dim.quad[1].z + (at->dim.quad[3].z + at->dim.quad[2].z))) / 4.0f;
-                Math_Vec3s_ToVec3f(&acPos2, &ac->dim.pos);
-                CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos2, &ac->base, &ac->info, &acPos2, &hitPos);
+                atPos2.x = (atQuad->dim.quad[0].x +
+                            (atQuad->dim.quad[1].x + (atQuad->dim.quad[3].x + atQuad->dim.quad[2].x))) /
+                           4.0f;
+                atPos2.y = (atQuad->dim.quad[0].y +
+                            (atQuad->dim.quad[1].y + (atQuad->dim.quad[3].y + atQuad->dim.quad[2].y))) /
+                           4.0f;
+                atPos2.z = (atQuad->dim.quad[0].z +
+                            (atQuad->dim.quad[1].z + (atQuad->dim.quad[3].z + atQuad->dim.quad[2].z))) /
+                           4.0f;
+                Math_Vec3s_ToVec3f(&acPos2, &acCyl->dim.pos);
+                CollisionCheck_SetATvsAC(play, &atQuad->base, &atQuad->elem, &atPos2, &acCyl->base, &acCyl->elem,
+                                         &acPos2, &hitPos);
             }
         }
     }
@@ -2271,40 +2301,44 @@ static s8 sBssDummy4;
 static s8 sBssDummy5;
 static s8 sBssDummy6;
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_TrisVsTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
+void CollisionCheck_ATTrisVsACTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                   Collider* acCol) {
     static Vec3f hitPos;
-    ColliderTris* at = (ColliderTris*)colAT;
-    ColliderTrisElement* atItem;
-    ColliderTris* ac = (ColliderTris*)colAC;
-    ColliderTrisElement* acElem;
+    ColliderTris* atTris = (ColliderTris*)atCol;
+    ColliderTrisElement* atTrisElem;
+    ColliderTris* acTris = (ColliderTris*)acCol;
+    ColliderTrisElement* acTrisElem;
 
-    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) == true) {
+    if (acTris->count > 0 && acTris->elements != NULL && atTris->count > 0 && atTris->elements != NULL) {
+        for (acTrisElem = acTris->elements; acTrisElem < acTris->elements + acTris->count; acTrisElem++) {
+            if (CollisionCheck_SkipElementBump(&acTrisElem->base) == true) {
                 continue;
             }
-            for (atItem = at->elements; atItem < at->elements + at->count; atItem++) {
-                if (CollisionCheck_SkipTouch(&atItem->info) == true) {
+            for (atTrisElem = atTris->elements; atTrisElem < atTris->elements + atTris->count; atTrisElem++) {
+                if (CollisionCheck_SkipElementTouch(&atTrisElem->base) == true) {
                     continue;
                 }
-                if (CollisionCheck_NoSharedFlags(&atItem->info, &acElem->info) == true) {
+                if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acTrisElem->base) == true) {
                     continue;
                 }
-                if (Math3D_TriVsTriIntersect(&atItem->dim, &acElem->dim, &hitPos) == true) {
+                if (Math3D_TriVsTriIntersect(&atTrisElem->dim, &acTrisElem->dim, &hitPos) == true) {
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    atPos.x = (atItem->dim.vtx[0].x + atItem->dim.vtx[1].x + atItem->dim.vtx[2].x) * (1.0f / 3);
-                    atPos.y = (atItem->dim.vtx[0].y + atItem->dim.vtx[1].y + atItem->dim.vtx[2].y) * (1.0f / 3);
-                    atPos.z = (atItem->dim.vtx[0].z + atItem->dim.vtx[1].z + atItem->dim.vtx[2].z) * (1.0f / 3);
-                    acPos.x = (acElem->dim.vtx[0].x + acElem->dim.vtx[1].x + acElem->dim.vtx[2].x) * (1.0f / 3);
-                    acPos.y = (acElem->dim.vtx[0].y + acElem->dim.vtx[1].y + acElem->dim.vtx[2].y) * (1.0f / 3);
-                    acPos.z = (acElem->dim.vtx[0].z + acElem->dim.vtx[1].z + acElem->dim.vtx[2].z) * (1.0f / 3);
-                    CollisionCheck_SetATvsAC(play, &at->base, &atItem->info, &atPos, &ac->base, &acElem->info, &acPos,
-                                             &hitPos);
+                    atPos.x =
+                        (atTrisElem->dim.vtx[0].x + atTrisElem->dim.vtx[1].x + atTrisElem->dim.vtx[2].x) * (1.0f / 3);
+                    atPos.y =
+                        (atTrisElem->dim.vtx[0].y + atTrisElem->dim.vtx[1].y + atTrisElem->dim.vtx[2].y) * (1.0f / 3);
+                    atPos.z =
+                        (atTrisElem->dim.vtx[0].z + atTrisElem->dim.vtx[1].z + atTrisElem->dim.vtx[2].z) * (1.0f / 3);
+                    acPos.x =
+                        (acTrisElem->dim.vtx[0].x + acTrisElem->dim.vtx[1].x + acTrisElem->dim.vtx[2].x) * (1.0f / 3);
+                    acPos.y =
+                        (acTrisElem->dim.vtx[0].y + acTrisElem->dim.vtx[1].y + acTrisElem->dim.vtx[2].y) * (1.0f / 3);
+                    acPos.z =
+                        (acTrisElem->dim.vtx[0].z + acTrisElem->dim.vtx[1].z + acTrisElem->dim.vtx[2].z) * (1.0f / 3);
+                    CollisionCheck_SetATvsAC(play, &atTris->base, &atTrisElem->base, &atPos, &acTris->base,
+                                             &acTrisElem->base, &acPos, &hitPos);
                     return;
                 }
             }
@@ -2317,89 +2351,98 @@ static s8 sBssDummy8;
 static s8 sBssDummy9;
 static s8 sBssDummy10;
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_TrisVsQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
+void CollisionCheck_ATTrisVsACQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                   Collider* acCol) {
     static Vec3f hitPos;
     static TriNorm tri1;
     static TriNorm tri2;
-    ColliderTris* at = (ColliderTris*)colAT;
-    ColliderTrisElement* atItem;
-    ColliderQuad* ac = (ColliderQuad*)colAC;
+    ColliderTris* atTris = (ColliderTris*)atCol;
+    ColliderTrisElement* atTrisElem;
+    ColliderQuad* acQuad = (ColliderQuad*)acCol;
 
-    if (at->count > 0 && at->elements != NULL) {
-        if (CollisionCheck_SkipBump(&ac->info) == true) {
+    if (atTris->count > 0 && atTris->elements != NULL) {
+        if (CollisionCheck_SkipElementBump(&acQuad->elem) == true) {
             return;
         }
-        Math3D_TriNorm(&tri1, &ac->dim.quad[2], &ac->dim.quad[3], &ac->dim.quad[1]);
-        Math3D_TriNorm(&tri2, &ac->dim.quad[1], &ac->dim.quad[0], &ac->dim.quad[2]);
-        for (atItem = at->elements; atItem < at->elements + at->count; atItem++) {
-            if (CollisionCheck_SkipTouch(&atItem->info) == true) {
+        Math3D_TriNorm(&tri1, &acQuad->dim.quad[2], &acQuad->dim.quad[3], &acQuad->dim.quad[1]);
+        Math3D_TriNorm(&tri2, &acQuad->dim.quad[1], &acQuad->dim.quad[0], &acQuad->dim.quad[2]);
+        for (atTrisElem = atTris->elements; atTrisElem < atTris->elements + atTris->count; atTrisElem++) {
+            if (CollisionCheck_SkipElementTouch(&atTrisElem->base) == true) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&atItem->info, &ac->info) == true) {
+            if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acQuad->elem) == true) {
                 continue;
             }
-            if (Math3D_TriVsTriIntersect(&tri1, &atItem->dim, &hitPos) == true ||
-                Math3D_TriVsTriIntersect(&tri2, &atItem->dim, &hitPos) == true) {
+            if (Math3D_TriVsTriIntersect(&tri1, &atTrisElem->dim, &hitPos) == true ||
+                Math3D_TriVsTriIntersect(&tri2, &atTrisElem->dim, &hitPos) == true) {
                 Vec3f atPos;
                 Vec3f acPos;
 
-                atPos.x = (atItem->dim.vtx[0].x + atItem->dim.vtx[1].x + atItem->dim.vtx[2].x) * (1.0f / 3);
-                atPos.y = (atItem->dim.vtx[0].y + atItem->dim.vtx[1].y + atItem->dim.vtx[2].y) * (1.0f / 3);
-                atPos.z = (atItem->dim.vtx[0].z + atItem->dim.vtx[1].z + atItem->dim.vtx[2].z) * (1.0f / 3);
-                acPos.x = (ac->dim.quad[0].x + (ac->dim.quad[1].x + (ac->dim.quad[3].x + ac->dim.quad[2].x))) / 4.0f;
-                acPos.y = (ac->dim.quad[0].y + (ac->dim.quad[1].y + (ac->dim.quad[3].y + ac->dim.quad[2].y))) / 4.0f;
-                acPos.z = (ac->dim.quad[0].z + (ac->dim.quad[1].z + (ac->dim.quad[3].z + ac->dim.quad[2].z))) / 4.0f;
-                CollisionCheck_SetATvsAC(play, &at->base, &atItem->info, &atPos, &ac->base, &ac->info, &acPos, &hitPos);
+                atPos.x = (atTrisElem->dim.vtx[0].x + atTrisElem->dim.vtx[1].x + atTrisElem->dim.vtx[2].x) * (1.0f / 3);
+                atPos.y = (atTrisElem->dim.vtx[0].y + atTrisElem->dim.vtx[1].y + atTrisElem->dim.vtx[2].y) * (1.0f / 3);
+                atPos.z = (atTrisElem->dim.vtx[0].z + atTrisElem->dim.vtx[1].z + atTrisElem->dim.vtx[2].z) * (1.0f / 3);
+                acPos.x = (acQuad->dim.quad[0].x +
+                           (acQuad->dim.quad[1].x + (acQuad->dim.quad[3].x + acQuad->dim.quad[2].x))) /
+                          4.0f;
+                acPos.y = (acQuad->dim.quad[0].y +
+                           (acQuad->dim.quad[1].y + (acQuad->dim.quad[3].y + acQuad->dim.quad[2].y))) /
+                          4.0f;
+                acPos.z = (acQuad->dim.quad[0].z +
+                           (acQuad->dim.quad[1].z + (acQuad->dim.quad[3].z + acQuad->dim.quad[2].z))) /
+                          4.0f;
+                CollisionCheck_SetATvsAC(play, &atTris->base, &atTrisElem->base, &atPos, &acQuad->base, &acQuad->elem,
+                                         &acPos, &hitPos);
                 return;
             }
         }
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_QuadVsTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
+void CollisionCheck_ATQuadVsACTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                   Collider* acCol) {
     static Vec3f hitPos;
     static TriNorm tri1;
     static TriNorm tri2;
-    ColliderQuad* at = (ColliderQuad*)colAT;
-    ColliderTris* ac = (ColliderTris*)colAC;
-    ColliderTrisElement* acElem;
+    ColliderQuad* atQuad = (ColliderQuad*)atCol;
+    ColliderTris* acTris = (ColliderTris*)acCol;
+    ColliderTrisElement* acTrisElem;
 
-    if (ac->count > 0 && ac->elements != NULL) {
-        if (CollisionCheck_SkipTouch(&at->info) == true) {
+    if (acTris->count > 0 && acTris->elements != NULL) {
+        if (CollisionCheck_SkipElementTouch(&atQuad->elem) == true) {
             return;
         }
-        Math3D_TriNorm(&tri1, &at->dim.quad[2], &at->dim.quad[3], &at->dim.quad[1]);
-        Math3D_TriNorm(&tri2, &at->dim.quad[1], &at->dim.quad[0], &at->dim.quad[2]);
-        for (acElem = ac->elements; acElem < ac->elements + ac->count; acElem++) {
-            if (CollisionCheck_SkipBump(&acElem->info) == true) {
+        Math3D_TriNorm(&tri1, &atQuad->dim.quad[2], &atQuad->dim.quad[3], &atQuad->dim.quad[1]);
+        Math3D_TriNorm(&tri2, &atQuad->dim.quad[1], &atQuad->dim.quad[0], &atQuad->dim.quad[2]);
+        for (acTrisElem = acTris->elements; acTrisElem < acTris->elements + acTris->count; acTrisElem++) {
+            if (CollisionCheck_SkipElementBump(&acTrisElem->base) == true) {
                 continue;
             }
-            if (CollisionCheck_NoSharedFlags(&at->info, &acElem->info) == true) {
+            if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acTrisElem->base) == true) {
                 continue;
             }
-            if (Math3D_TriVsTriIntersect(&tri1, &acElem->dim, &hitPos) == true ||
-                Math3D_TriVsTriIntersect(&tri2, &acElem->dim, &hitPos) == true) {
-                if (Collider_QuadSetNearestAC(play, at, &hitPos)) {
+            if (Math3D_TriVsTriIntersect(&tri1, &acTrisElem->dim, &hitPos) == true ||
+                Math3D_TriVsTriIntersect(&tri2, &acTrisElem->dim, &hitPos) == true) {
+                if (Collider_QuadSetNearestAC(play, atQuad, &hitPos)) {
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    acPos.x = (acElem->dim.vtx[0].x + acElem->dim.vtx[1].x + acElem->dim.vtx[2].x) * (1.0f / 3);
-                    acPos.y = (acElem->dim.vtx[0].y + acElem->dim.vtx[1].y + acElem->dim.vtx[2].y) * (1.0f / 3);
-                    acPos.z = (acElem->dim.vtx[0].z + acElem->dim.vtx[1].z + acElem->dim.vtx[2].z) * (1.0f / 3);
-                    atPos.x =
-                        (at->dim.quad[0].x + (at->dim.quad[1].x + (at->dim.quad[3].x + at->dim.quad[2].x))) / 4.0f;
-                    atPos.y =
-                        (at->dim.quad[0].y + (at->dim.quad[1].y + (at->dim.quad[3].y + at->dim.quad[2].y))) / 4.0f;
-                    atPos.z =
-                        (at->dim.quad[0].z + (at->dim.quad[1].z + (at->dim.quad[3].z + at->dim.quad[2].z))) / 4.0f;
-                    CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &ac->base, &acElem->info, &acPos,
-                                             &hitPos);
+                    acPos.x =
+                        (acTrisElem->dim.vtx[0].x + acTrisElem->dim.vtx[1].x + acTrisElem->dim.vtx[2].x) * (1.0f / 3);
+                    acPos.y =
+                        (acTrisElem->dim.vtx[0].y + acTrisElem->dim.vtx[1].y + acTrisElem->dim.vtx[2].y) * (1.0f / 3);
+                    acPos.z =
+                        (acTrisElem->dim.vtx[0].z + acTrisElem->dim.vtx[1].z + acTrisElem->dim.vtx[2].z) * (1.0f / 3);
+                    atPos.x = (atQuad->dim.quad[0].x +
+                               (atQuad->dim.quad[1].x + (atQuad->dim.quad[3].x + atQuad->dim.quad[2].x))) /
+                              4.0f;
+                    atPos.y = (atQuad->dim.quad[0].y +
+                               (atQuad->dim.quad[1].y + (atQuad->dim.quad[3].y + atQuad->dim.quad[2].y))) /
+                              4.0f;
+                    atPos.z = (atQuad->dim.quad[0].z +
+                               (atQuad->dim.quad[1].z + (atQuad->dim.quad[3].z + atQuad->dim.quad[2].z))) /
+                              4.0f;
+                    CollisionCheck_SetATvsAC(play, &atQuad->base, &atQuad->elem, &atPos, &acTris->base,
+                                             &acTrisElem->base, &acPos, &hitPos);
                     return;
                 }
             }
@@ -2407,53 +2450,58 @@ void CollisionCheck_AC_QuadVsTris(PlayState* play, CollisionCheckContext* colChk
     }
 }
 
-/**
- * AC overlap check. Calculates the center of each collider element and the point of contact.
- */
-void CollisionCheck_AC_QuadVsQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT, Collider* colAC) {
+void CollisionCheck_ATQuadVsACQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol,
+                                   Collider* acCol) {
     static TriNorm acTris[2];
     static Vec3f hitPos;
     static TriNorm atTris[2];
-    ColliderQuad* at = (ColliderQuad*)colAT;
-    ColliderQuad* ac = (ColliderQuad*)colAC;
+    ColliderQuad* atQuad = (ColliderQuad*)atCol;
+    ColliderQuad* acQuad = (ColliderQuad*)acCol;
     s32 i;
     s32 j;
 
-    if (CollisionCheck_SkipTouch(&at->info) == true) {
+    if (CollisionCheck_SkipElementTouch(&atQuad->elem) == true) {
         return;
     }
-    if (CollisionCheck_SkipBump(&ac->info) == true) {
+    if (CollisionCheck_SkipElementBump(&acQuad->elem) == true) {
         return;
     }
-    if (CollisionCheck_NoSharedFlags(&at->info, &ac->info) == true) {
+    if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acQuad->elem) == true) {
         return;
     }
 
-    Math3D_TriNorm(&atTris[0], &at->dim.quad[2], &at->dim.quad[3], &at->dim.quad[1]);
-    Math3D_TriNorm(&atTris[1], &at->dim.quad[2], &at->dim.quad[1], &at->dim.quad[0]);
-    Math3D_TriNorm(&acTris[0], &ac->dim.quad[2], &ac->dim.quad[3], &ac->dim.quad[1]);
-    Math3D_TriNorm(&acTris[1], &ac->dim.quad[2], &ac->dim.quad[1], &ac->dim.quad[0]);
+    Math3D_TriNorm(&atTris[0], &atQuad->dim.quad[2], &atQuad->dim.quad[3], &atQuad->dim.quad[1]);
+    Math3D_TriNorm(&atTris[1], &atQuad->dim.quad[2], &atQuad->dim.quad[1], &atQuad->dim.quad[0]);
+    Math3D_TriNorm(&acTris[0], &acQuad->dim.quad[2], &acQuad->dim.quad[3], &acQuad->dim.quad[1]);
+    Math3D_TriNorm(&acTris[1], &acQuad->dim.quad[2], &acQuad->dim.quad[1], &acQuad->dim.quad[0]);
 
     for (i = 0; i < 2; i++) {
         for (j = 0; j < 2; j++) {
             if (Math3D_TriVsTriIntersect(&atTris[j], &acTris[i], &hitPos) == true) {
-                if (Collider_QuadSetNearestAC(play, at, &hitPos)) {
+                if (Collider_QuadSetNearestAC(play, atQuad, &hitPos)) {
                     Vec3f atPos;
                     Vec3f acPos;
 
-                    atPos.x =
-                        (at->dim.quad[0].x + (at->dim.quad[1].x + (at->dim.quad[3].x + at->dim.quad[2].x))) / 4.0f;
-                    atPos.y =
-                        (at->dim.quad[0].y + (at->dim.quad[1].y + (at->dim.quad[3].y + at->dim.quad[2].y))) / 4.0f;
-                    atPos.z =
-                        (at->dim.quad[0].z + (at->dim.quad[1].z + (at->dim.quad[3].z + at->dim.quad[2].z))) / 4.0f;
-                    acPos.x =
-                        (ac->dim.quad[0].x + (ac->dim.quad[1].x + (ac->dim.quad[3].x + ac->dim.quad[2].x))) / 4.0f;
-                    acPos.y =
-                        (ac->dim.quad[0].y + (ac->dim.quad[1].y + (ac->dim.quad[3].y + ac->dim.quad[2].y))) / 4.0f;
-                    acPos.z =
-                        (ac->dim.quad[0].z + (ac->dim.quad[1].z + (ac->dim.quad[3].z + ac->dim.quad[2].z))) / 4.0f;
-                    CollisionCheck_SetATvsAC(play, &at->base, &at->info, &atPos, &ac->base, &ac->info, &acPos, &hitPos);
+                    atPos.x = (atQuad->dim.quad[0].x +
+                               (atQuad->dim.quad[1].x + (atQuad->dim.quad[3].x + atQuad->dim.quad[2].x))) /
+                              4.0f;
+                    atPos.y = (atQuad->dim.quad[0].y +
+                               (atQuad->dim.quad[1].y + (atQuad->dim.quad[3].y + atQuad->dim.quad[2].y))) /
+                              4.0f;
+                    atPos.z = (atQuad->dim.quad[0].z +
+                               (atQuad->dim.quad[1].z + (atQuad->dim.quad[3].z + atQuad->dim.quad[2].z))) /
+                              4.0f;
+                    acPos.x = (acQuad->dim.quad[0].x +
+                               (acQuad->dim.quad[1].x + (acQuad->dim.quad[3].x + acQuad->dim.quad[2].x))) /
+                              4.0f;
+                    acPos.y = (acQuad->dim.quad[0].y +
+                               (acQuad->dim.quad[1].y + (acQuad->dim.quad[3].y + acQuad->dim.quad[2].y))) /
+                              4.0f;
+                    acPos.z = (acQuad->dim.quad[0].z +
+                               (acQuad->dim.quad[1].z + (acQuad->dim.quad[3].z + acQuad->dim.quad[2].z))) /
+                              4.0f;
+                    CollisionCheck_SetATvsAC(play, &atQuad->base, &atQuad->elem, &atPos, &acQuad->base, &acQuad->elem,
+                                             &acPos, &hitPos);
                     return;
                 }
             }
@@ -2461,74 +2509,61 @@ void CollisionCheck_AC_QuadVsQuad(PlayState* play, CollisionCheckContext* colChk
     }
 }
 
-/**
- * Sets a ColliderJntSph's hit effects
- */
-void CollisionCheck_SetJntSphHitFX(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider) {
-    ColliderJntSph* jntSph = (ColliderJntSph*)collider;
-    ColliderJntSphElement* element;
+void CollisionCheck_SetJntSphHitFX(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
+    ColliderJntSph* jntSph = (ColliderJntSph*)col;
+    ColliderJntSphElement* jntSphElem;
     Vec3f hitPos;
 
-    for (element = jntSph->elements; element < jntSph->elements + jntSph->count; element++) {
-        if ((element->info.bumperFlags & BUMP_DRAW_HITMARK) && (element->info.acHitInfo != NULL) &&
-            !(element->info.acHitInfo->toucherFlags & TOUCH_DREW_HITMARK)) {
-            Math_Vec3s_ToVec3f(&hitPos, &element->info.bumper.hitPos);
-            CollisionCheck_HitEffects(play, element->info.acHit, element->info.acHitInfo, &jntSph->base, &element->info,
-                                      &hitPos);
-            element->info.acHitInfo->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)) {
+            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;
         }
     }
 }
 
-/**
- * Sets a ColliderCylinder's hit effects
- */
-void CollisionCheck_SetCylHitFX(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider) {
-    ColliderCylinder* cylinder = (ColliderCylinder*)collider;
+void CollisionCheck_SetCylHitFX(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
+    ColliderCylinder* cyl = (ColliderCylinder*)col;
     Vec3f hitPos;
 
-    if ((cylinder->info.bumperFlags & BUMP_DRAW_HITMARK) && (cylinder->info.acHitInfo != NULL) &&
-        !(cylinder->info.acHitInfo->toucherFlags & TOUCH_DREW_HITMARK)) {
-        Math_Vec3s_ToVec3f(&hitPos, &cylinder->info.bumper.hitPos);
-        CollisionCheck_HitEffects(play, cylinder->info.acHit, cylinder->info.acHitInfo, &cylinder->base,
-                                  &cylinder->info, &hitPos);
-        cylinder->info.acHitInfo->toucherFlags |= TOUCH_DREW_HITMARK;
+    if ((cyl->elem.bumperFlags & BUMP_DRAW_HITMARK) && (cyl->elem.acHitElem != NULL) &&
+        !(cyl->elem.acHitElem->toucherFlags & TOUCH_DREW_HITMARK)) {
+        Math_Vec3s_ToVec3f(&hitPos, &cyl->elem.bumper.hitPos);
+        CollisionCheck_HitEffects(play, cyl->elem.acHit, cyl->elem.acHitElem, &cyl->base, &cyl->elem, &hitPos);
+        cyl->elem.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
     }
 }
 
-/**
- * Sets a ColliderTris's hit effects
- */
-void CollisionCheck_SetTrisHitFX(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider) {
-    ColliderTris* tris = (ColliderTris*)collider;
-    ColliderTrisElement* element;
+void CollisionCheck_SetTrisHitFX(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
+    ColliderTris* tris = (ColliderTris*)col;
+    ColliderTrisElement* trisElem;
     Vec3f hitPos;
 
-    for (element = tris->elements; element < tris->elements + tris->count; element++) {
-        if ((element->info.bumperFlags & BUMP_DRAW_HITMARK) && (element->info.acHitInfo != NULL) &&
-            !(element->info.acHitInfo->toucherFlags & TOUCH_DREW_HITMARK)) {
-            Math_Vec3s_ToVec3f(&hitPos, &element->info.bumper.hitPos);
-            CollisionCheck_HitEffects(play, element->info.acHit, element->info.acHitInfo, &tris->base, &element->info,
-                                      &hitPos);
-            element->info.acHitInfo->toucherFlags |= TOUCH_DREW_HITMARK;
+    for (trisElem = tris->elements; trisElem < tris->elements + tris->count; trisElem++) {
+        if ((trisElem->base.bumperFlags & BUMP_DRAW_HITMARK) && (trisElem->base.acHitElem != NULL) &&
+            !(trisElem->base.acHitElem->toucherFlags & TOUCH_DREW_HITMARK)) {
+            Math_Vec3s_ToVec3f(&hitPos, &trisElem->base.bumper.hitPos);
+            CollisionCheck_HitEffects(play, trisElem->base.acHit, trisElem->base.acHitElem, &tris->base,
+                                      &trisElem->base, &hitPos);
+            trisElem->base.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
             return;
         }
     }
 }
 
-/**
- * Sets a ColliderQuad's hit effects
- */
-void CollisionCheck_SetQuadHitFX(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider) {
-    ColliderQuad* quad = (ColliderQuad*)collider;
+void CollisionCheck_SetQuadHitFX(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
+    ColliderQuad* quad = (ColliderQuad*)col;
     Vec3f hitPos;
 
-    if ((quad->info.bumperFlags & BUMP_DRAW_HITMARK) && (quad->info.acHitInfo != NULL) &&
-        !(quad->info.acHitInfo->toucherFlags & TOUCH_DREW_HITMARK)) {
-        Math_Vec3s_ToVec3f(&hitPos, &quad->info.bumper.hitPos);
-        CollisionCheck_HitEffects(play, quad->info.acHit, quad->info.acHitInfo, &quad->base, &quad->info, &hitPos);
-        quad->info.acHitInfo->toucherFlags |= TOUCH_DREW_HITMARK;
+    if ((quad->elem.bumperFlags & BUMP_DRAW_HITMARK) && (quad->elem.acHitElem != NULL) &&
+        !(quad->elem.acHitElem->toucherFlags & TOUCH_DREW_HITMARK)) {
+        Math_Vec3s_ToVec3f(&hitPos, &quad->elem.bumper.hitPos);
+        CollisionCheck_HitEffects(play, quad->elem.acHit, quad->elem.acHitElem, &quad->base, &quad->elem, &hitPos);
+        quad->elem.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
     }
 }
 
@@ -2543,49 +2578,69 @@ static ColChkApplyFunc sColChkApplyFuncs[] = {
  * Handles hit effects for each AC collider that had an AC collision. Spawns hitmarks and plays sound effects.
  */
 void CollisionCheck_SetHitEffects(PlayState* play, CollisionCheckContext* colChkCtx) {
-    Collider** col;
+    Collider** acColP;
 
-    for (col = colChkCtx->colAC; col < colChkCtx->colAC + colChkCtx->colACCount; col++) {
-        Collider* colAC = *col;
+    for (acColP = colChkCtx->colAC; acColP < colChkCtx->colAC + colChkCtx->colACCount; acColP++) {
+        Collider* acCol = *acColP;
 
-        if (colAC != NULL && colAC->acFlags & AC_ON) {
-            if (colAC->actor != NULL && colAC->actor->update == NULL) {
+        if (acCol != NULL && acCol->acFlags & AC_ON) {
+            if (acCol->actor != NULL && acCol->actor->update == NULL) {
                 continue;
             }
-            sColChkApplyFuncs[colAC->shape](play, colChkCtx, colAC);
+            sColChkApplyFuncs[acCol->shape](play, colChkCtx, acCol);
         }
     }
 }
 
 static ColChkVsFunc sACVsFuncs[COLSHAPE_MAX][COLSHAPE_MAX] = {
-    { CollisionCheck_AC_JntSphVsJntSph, CollisionCheck_AC_JntSphVsCyl, CollisionCheck_AC_JntSphVsTris,
-      CollisionCheck_AC_JntSphVsQuad },
-    { CollisionCheck_AC_CylVsJntSph, CollisionCheck_AC_CylVsCyl, CollisionCheck_AC_CylVsTris,
-      CollisionCheck_AC_CylVsQuad },
-    { CollisionCheck_AC_TrisVsJntSph, CollisionCheck_AC_TrisVsCyl, CollisionCheck_AC_TrisVsTris,
-      CollisionCheck_AC_TrisVsQuad },
-    { CollisionCheck_AC_QuadVsJntSph, CollisionCheck_AC_QuadVsCyl, CollisionCheck_AC_QuadVsTris,
-      CollisionCheck_AC_QuadVsQuad },
+    // COLSHAPE_JNTSPH
+    {
+        CollisionCheck_ATJntSphVsACJntSph, // COLSHAPE_JNTSPH
+        CollisionCheck_ATJntSphVsACCyl,    // COLSHAPE_CYLINDER
+        CollisionCheck_ATJntSphVsACTris,   // COLSHAPE_TRIS
+        CollisionCheck_ATJntSphVsACQuad    // COLSHAPE_QUAD
+    },
+    // COLSHAPE_CYLINDER
+    {
+        CollisionCheck_ATCylVsACJntSph, // COLSHAPE_JNTSPH
+        CollisionCheck_ATCylVsACCyl,    // COLSHAPE_CYLINDER
+        CollisionCheck_ATCylVsACTris,   // COLSHAPE_TRIS
+        CollisionCheck_ATCylVsACQuad    // COLSHAPE_QUAD
+    },
+    // COLSHAPE_TRIS
+    {
+        CollisionCheck_ATTrisVsACJntSph, // COLSHAPE_JNTSPH
+        CollisionCheck_ATTrisVsACCyl,    // COLSHAPE_CYLINDER
+        CollisionCheck_ATTrisVsACTris,   // COLSHAPE_TRIS
+        CollisionCheck_ATTrisVsACQuad    // COLSHAPE_QUAD
+    },
+    // COLSHAPE_QUAD
+    {
+        CollisionCheck_ATQuadVsACJntSph, // COLSHAPE_JNTSPH
+        CollisionCheck_ATQuadVsACCyl,    // COLSHAPE_CYLINDER
+        CollisionCheck_ATQuadVsACTris,   // COLSHAPE_TRIS
+        CollisionCheck_ATQuadVsACQuad    // COLSHAPE_QUAD
+    },
 };
 
 /**
  * Iterates through all AC colliders, performing AC collisions with the AT collider.
  */
-void CollisionCheck_AC(PlayState* play, CollisionCheckContext* colChkCtx, Collider* colAT) {
-    Collider** col;
+void CollisionCheck_AC(PlayState* play, CollisionCheckContext* colChkCtx, Collider* atCol) {
+    Collider** acColP;
 
-    for (col = colChkCtx->colAC; col < colChkCtx->colAC + colChkCtx->colACCount; col++) {
-        Collider* colAC = *col;
+    for (acColP = colChkCtx->colAC; acColP < colChkCtx->colAC + colChkCtx->colACCount; acColP++) {
+        Collider* acCol = *acColP;
 
-        if (colAC != NULL && colAC->acFlags & AC_ON) {
-            if (colAC->actor != NULL && colAC->actor->update == NULL) {
+        if (acCol != NULL && acCol->acFlags & AC_ON) {
+            if (acCol->actor != NULL && acCol->actor->update == NULL) {
                 continue;
             }
-            if ((colAC->acFlags & colAT->atFlags & AC_TYPE_ALL) && (colAT != colAC)) {
-                if (!(colAT->atFlags & AT_SELF) && colAT->actor != NULL && colAC->actor == colAT->actor) {
+            if ((acCol->acFlags & atCol->atFlags & AC_TYPE_ALL) && (atCol != acCol)) {
+                if (!(atCol->atFlags & AT_SELF) && atCol->actor != NULL && acCol->actor == atCol->actor) {
                     continue;
                 }
-                sACVsFuncs[colAT->shape][colAC->shape](play, colChkCtx, colAT, colAC);
+                sACVsFuncs[atCol->shape][acCol->shape](play, colChkCtx, atCol, acCol);
             }
         }
     }
@@ -2598,26 +2653,32 @@ void CollisionCheck_AC(PlayState* play, CollisionCheckContext* colChkCtx, Collid
  * with the AC collider and the toucher and bumper elements that overlapped must share a dmgFlag.
  */
 void CollisionCheck_AT(PlayState* play, CollisionCheckContext* colChkCtx) {
-    Collider** col;
+    Collider** atColP;
 
     if (colChkCtx->colATCount == 0 || colChkCtx->colACCount == 0) {
         return;
     }
-    for (col = colChkCtx->colAT; col < colChkCtx->colAT + colChkCtx->colATCount; col++) {
-        Collider* colAT = *col;
+    for (atColP = colChkCtx->colAT; atColP < colChkCtx->colAT + colChkCtx->colATCount; atColP++) {
+        Collider* atCol = *atColP;
 
-        if (colAT != NULL && colAT->atFlags & AT_ON) {
-            if (colAT->actor != NULL && colAT->actor->update == NULL) {
+        if (atCol != NULL && atCol->atFlags & AT_ON) {
+            if (atCol->actor != NULL && atCol->actor->update == NULL) {
                 continue;
             }
-            CollisionCheck_AC(play, colChkCtx, colAT);
+            CollisionCheck_AC(play, colChkCtx, atCol);
         }
     }
     CollisionCheck_SetHitEffects(play, colChkCtx);
 }
 
+typedef enum {
+    /* 0 */ MASSTYPE_IMMOVABLE,
+    /* 1 */ MASSTYPE_HEAVY,
+    /* 2 */ MASSTYPE_NORMAL
+} ColChkMassType;
+
 /**
- * Get mass type. Immobile colliders cannot be pushed, while heavy colliders can only be pushed by heavy and immobile
+ * Get mass type. Immovable colliders cannot be pushed, while heavy colliders can only be pushed by heavy and immovable
  * colliders.
  */
 s32 CollisionCheck_GetMassType(u8 mass) {
@@ -2634,8 +2695,8 @@ s32 CollisionCheck_GetMassType(u8 mass) {
  * Sets OC collision flags for OC collider overlaps. If both colliders are attached to actors and can push,
  * also performs an elastic collision where both colliders are moved apart in proportion to their masses.
  */
-void CollisionCheck_SetOCvsOC(Collider* left, ColliderInfo* leftInfo, Vec3f* leftPos, Collider* right,
-                              ColliderInfo* rightInfo, Vec3f* rightPos, f32 overlap) {
+void CollisionCheck_SetOCvsOC(Collider* leftCol, ColliderElement* leftElem, Vec3f* leftPos, Collider* rightCol,
+                              ColliderElement* rightElem, Vec3f* rightPos, f32 overlap) {
     f32 pad;
     f32 leftDispRatio;
     f32 rightDispRatio;
@@ -2646,24 +2707,25 @@ void CollisionCheck_SetOCvsOC(Collider* left, ColliderInfo* leftInfo, Vec3f* lef
     f32 inverseTotalMass;
     f32 xDelta;
     f32 zDelta;
-    Actor* leftActor = left->actor;
-    Actor* rightActor = right->actor;
+    Actor* leftActor = leftCol->actor;
+    Actor* rightActor = rightCol->actor;
     s32 rightMassType;
     s32 leftMassType;
 
-    left->ocFlags1 |= OC1_HIT;
-    left->oc = rightActor;
-    leftInfo->ocElemFlags |= OCELEM_HIT;
-    if (right->ocFlags2 & OC2_TYPE_PLAYER) {
-        left->ocFlags2 |= OC2_HIT_PLAYER;
+    leftCol->ocFlags1 |= OC1_HIT;
+    leftCol->oc = rightActor;
+    leftElem->ocElemFlags |= OCELEM_HIT;
+    if (rightCol->ocFlags2 & OC2_TYPE_PLAYER) {
+        leftCol->ocFlags2 |= OC2_HIT_PLAYER;
     }
-    right->oc = leftActor;
-    right->ocFlags1 |= OC1_HIT;
-    rightInfo->ocElemFlags |= OCELEM_HIT;
-    if (left->ocFlags2 & OC2_TYPE_PLAYER) {
-        right->ocFlags2 |= OC2_HIT_PLAYER;
+    rightCol->oc = leftActor;
+    rightCol->ocFlags1 |= OC1_HIT;
+    rightElem->ocElemFlags |= OCELEM_HIT;
+    if (leftCol->ocFlags2 & OC2_TYPE_PLAYER) {
+        rightCol->ocFlags2 |= OC2_HIT_PLAYER;
     }
-    if (leftActor == NULL || rightActor == NULL || left->ocFlags1 & OC1_NO_PUSH || right->ocFlags1 & OC1_NO_PUSH) {
+    if (leftActor == NULL || rightActor == NULL || leftCol->ocFlags1 & OC1_NO_PUSH ||
+        rightCol->ocFlags1 & OC1_NO_PUSH) {
         return;
     }
     leftMassType = CollisionCheck_GetMassType(leftActor->colChkInfo.mass);
@@ -2724,94 +2786,91 @@ void CollisionCheck_SetOCvsOC(Collider* left, ColliderInfo* leftInfo, Vec3f* lef
     }
 }
 
-/**
- * OC overlap check for two JntSphs
- */
-void CollisionCheck_OC_JntSphVsJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* l, Collider* r) {
-    ColliderJntSph* left = (ColliderJntSph*)l;
-    ColliderJntSphElement* leftElem;
-    ColliderJntSph* right = (ColliderJntSph*)r;
-    ColliderJntSphElement* rightElem;
+void CollisionCheck_OC_JntSphVsJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* leftCol,
+                                      Collider* rightCol) {
+    ColliderJntSph* leftJntSph = (ColliderJntSph*)leftCol;
+    ColliderJntSphElement* leftJntSphElem;
+    ColliderJntSph* rightJntSph = (ColliderJntSph*)rightCol;
+    ColliderJntSphElement* rightJntSphElem;
     f32 overlapSize;
 
-    if (left->count > 0 && left->elements != NULL && right->count > 0 && right->elements != NULL) {
-        for (leftElem = left->elements; leftElem < left->elements + left->count; leftElem++) {
-            if (!(leftElem->info.ocElemFlags & OCELEM_ON)) {
+    if (leftJntSph->count > 0 && leftJntSph->elements != NULL && rightJntSph->count > 0 &&
+        rightJntSph->elements != NULL) {
+        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) ==
                     true) {
                     Vec3f leftPos;
                     Vec3f rightPos;
 
-                    Math_Vec3s_ToVec3f(&leftPos, &leftElem->dim.worldSphere.center);
-                    Math_Vec3s_ToVec3f(&rightPos, &rightElem->dim.worldSphere.center);
-                    CollisionCheck_SetOCvsOC(&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(&leftJntSph->base, &leftJntSphElem->base, &leftPos, &rightJntSph->base,
+                                             &rightJntSphElem->base, &rightPos, overlapSize);
                 }
             }
         }
     }
 }
 
-/**
- * OC overlap check for a JntSph and Cylinder
- */
-void CollisionCheck_OC_JntSphVsCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* l, Collider* r) {
-    ColliderJntSph* left = (ColliderJntSph*)l;
-    ColliderJntSphElement* leftElem;
-    ColliderCylinder* right = (ColliderCylinder*)r;
+void CollisionCheck_OC_JntSphVsCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* leftCol,
+                                   Collider* rightCol) {
+    ColliderJntSph* leftJntSph = (ColliderJntSph*)leftCol;
+    ColliderJntSphElement* leftJntSphElem;
+    ColliderCylinder* rightCyl = (ColliderCylinder*)rightCol;
     f32 overlapSize;
 
-    if (left->count > 0 && left->elements != NULL) {
-        if ((right->base.ocFlags1 & OC1_ON) && (right->info.ocElemFlags & OCELEM_ON)) {
-            for (leftElem = left->elements; leftElem < left->elements + left->count; leftElem++) {
-                if (!(leftElem->info.ocElemFlags & OCELEM_ON)) {
+    if (leftJntSph->count > 0 && leftJntSph->elements != NULL) {
+        if ((rightCyl->base.ocFlags1 & OC1_ON) && (rightCyl->elem.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) == true) {
+                if (Math3D_SphVsCylOverlap(&leftJntSphElem->dim.worldSphere, &rightCyl->dim, &overlapSize) == true) {
                     Vec3f leftPos;
                     Vec3f rightPos;
 
-                    Math_Vec3s_ToVec3f(&leftPos, &leftElem->dim.worldSphere.center);
-                    Math_Vec3s_ToVec3f(&rightPos, &right->dim.pos);
-                    CollisionCheck_SetOCvsOC(&left->base, &leftElem->info, &leftPos, &right->base, &right->info,
-                                             &rightPos, overlapSize);
+                    Math_Vec3s_ToVec3f(&leftPos, &leftJntSphElem->dim.worldSphere.center);
+                    Math_Vec3s_ToVec3f(&rightPos, &rightCyl->dim.pos);
+                    CollisionCheck_SetOCvsOC(&leftJntSph->base, &leftJntSphElem->base, &leftPos, &rightCyl->base,
+                                             &rightCyl->elem, &rightPos, overlapSize);
                 }
             }
         }
     }
 }
 
-/**
- * OC overlap check for a Cylinder and JntSph
- */
-void CollisionCheck_OC_CylVsJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* l, Collider* r) {
-    CollisionCheck_OC_JntSphVsCyl(play, colChkCtx, r, l);
+void CollisionCheck_OC_CylVsJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* leftCol,
+                                   Collider* rightCol) {
+    CollisionCheck_OC_JntSphVsCyl(play, colChkCtx, rightCol, leftCol);
 }
 
-/**
- * OC overlap check for two Cylinders
- */
-void CollisionCheck_OC_CylVsCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* l, Collider* r) {
-    ColliderCylinder* left = (ColliderCylinder*)l;
-    ColliderCylinder* right = (ColliderCylinder*)r;
+void CollisionCheck_OC_CylVsCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* leftCol,
+                                Collider* rightCol) {
+    ColliderCylinder* leftCyl = (ColliderCylinder*)leftCol;
+    ColliderCylinder* rightCyl = (ColliderCylinder*)rightCol;
     f32 overlapSize;
 
-    if ((left->base.ocFlags1 & OC1_ON) && (right->base.ocFlags1 & OC1_ON)) {
-        if ((left->info.ocElemFlags & OCELEM_ON) && (right->info.ocElemFlags & OCELEM_ON)) {
-            if (Math3D_CylVsCylOverlap(&left->dim, &right->dim, &overlapSize) == true) {
+    if ((leftCyl->base.ocFlags1 & OC1_ON) && (rightCyl->base.ocFlags1 & OC1_ON)) {
+        if ((leftCyl->elem.ocElemFlags & OCELEM_ON) && (rightCyl->elem.ocElemFlags & OCELEM_ON)) {
+            if (Math3D_CylVsCylOverlap(&leftCyl->dim, &rightCyl->dim, &overlapSize) == true) {
                 Vec3f leftPos;
                 Vec3f rightPos;
 
-                Math_Vec3s_ToVec3f(&leftPos, &left->dim.pos);
-                Math_Vec3s_ToVec3f(&rightPos, &right->dim.pos);
-                CollisionCheck_SetOCvsOC(&left->base, &left->info, &leftPos, &right->base, &right->info, &rightPos,
-                                         overlapSize);
+                Math_Vec3s_ToVec3f(&leftPos, &leftCyl->dim.pos);
+                Math_Vec3s_ToVec3f(&rightPos, &rightCyl->dim.pos);
+                CollisionCheck_SetOCvsOC(&leftCyl->base, &leftCyl->elem, &leftPos, &rightCyl->base, &rightCyl->elem,
+                                         &rightPos, overlapSize);
             }
         }
     }
@@ -2834,7 +2893,7 @@ s32 CollisionCheck_SkipOC(Collider* collider) {
  * Third, the colliders can't collide if they belong to the same actor
  */
 s32 CollisionCheck_Incompatible(Collider* left, Collider* right) {
-    if (!(left->ocFlags1 & right->ocFlags2 & OC1_TYPE_ALL) || !(left->ocFlags2 & right->ocFlags1 & OC1_TYPE_ALL) ||
+    if (!((left->ocFlags1 & right->ocFlags2 & OC1_TYPE_ALL) && (left->ocFlags2 & right->ocFlags1 & OC1_TYPE_ALL)) ||
         ((left->ocFlags2 & OC2_UNK1) && (right->ocFlags2 & OC2_UNK2)) ||
         ((right->ocFlags2 & OC2_UNK1) && (left->ocFlags2 & OC2_UNK2))) {
         return true;
@@ -2846,10 +2905,34 @@ s32 CollisionCheck_Incompatible(Collider* left, Collider* right) {
 }
 
 static ColChkVsFunc sOCVsFuncs[COLSHAPE_MAX][COLSHAPE_MAX] = {
-    { CollisionCheck_OC_JntSphVsJntSph, CollisionCheck_OC_JntSphVsCyl, NULL, NULL },
-    { CollisionCheck_OC_CylVsJntSph, CollisionCheck_OC_CylVsCyl, NULL, NULL },
-    { NULL, NULL, NULL, NULL },
-    { NULL, NULL, NULL, NULL },
+    // COLSHAPE_JNTSPH
+    {
+        CollisionCheck_OC_JntSphVsJntSph, // COLSHAPE_JNTSPH
+        CollisionCheck_OC_JntSphVsCyl,    // COLSHAPE_CYLINDER
+        NULL,                             // COLSHAPE_TRIS
+        NULL                              // COLSHAPE_QUAD
+    },
+    // COLSHAPE_CYLINDER
+    {
+        CollisionCheck_OC_CylVsJntSph, // COLSHAPE_JNTSPH
+        CollisionCheck_OC_CylVsCyl,    // COLSHAPE_CYLINDER
+        NULL,                          // COLSHAPE_TRIS
+        NULL                           // COLSHAPE_QUAD
+    },
+    // COLSHAPE_TRIS
+    {
+        NULL, // COLSHAPE_JNTSPH
+        NULL, // COLSHAPE_CYLINDER
+        NULL, // COLSHAPE_TRIS
+        NULL  // COLSHAPE_QUAD
+    },
+    // COLSHAPE_QUAD
+    {
+        NULL, // COLSHAPE_JNTSPH
+        NULL, // COLSHAPE_CYLINDER
+        NULL, // COLSHAPE_TRIS
+        NULL  // COLSHAPE_QUAD
+    },
 };
 
 /**
@@ -2860,26 +2943,26 @@ static ColChkVsFunc sOCVsFuncs[COLSHAPE_MAX][COLSHAPE_MAX] = {
  * cannot collide with OC2_UNK2, nor can two colliders that share an actor.
  */
 void CollisionCheck_OC(PlayState* play, CollisionCheckContext* colChkCtx) {
-    Collider** left;
-    Collider** right;
+    Collider** leftColP;
+    Collider** rightColP;
     ColChkVsFunc vsFunc;
 
-    for (left = colChkCtx->colOC; left < colChkCtx->colOC + colChkCtx->colOCCount; left++) {
-        if (*left == NULL || CollisionCheck_SkipOC(*left) == true) {
+    for (leftColP = colChkCtx->colOC; leftColP < colChkCtx->colOC + colChkCtx->colOCCount; leftColP++) {
+        if (*leftColP == NULL || CollisionCheck_SkipOC(*leftColP) == true) {
             continue;
         }
-        for (right = left + 1; right < colChkCtx->colOC + colChkCtx->colOCCount; right++) {
-            if (*right == NULL || CollisionCheck_SkipOC(*right) == true ||
-                CollisionCheck_Incompatible(*left, *right) == true) {
+        for (rightColP = leftColP + 1; rightColP < colChkCtx->colOC + colChkCtx->colOCCount; rightColP++) {
+            if (*rightColP == NULL || CollisionCheck_SkipOC(*rightColP) == true ||
+                CollisionCheck_Incompatible(*leftColP, *rightColP) == true) {
                 continue;
             }
-            vsFunc = sOCVsFuncs[(*left)->shape][(*right)->shape];
+            vsFunc = sOCVsFuncs[(*leftColP)->shape][(*rightColP)->shape];
             if (vsFunc == NULL) {
                 // "Not compatible"
-                osSyncPrintf("CollisionCheck_OC():未対応 %d, %d\n", (*left)->shape, (*right)->shape);
+                osSyncPrintf("CollisionCheck_OC():未対応 %d, %d\n", (*leftColP)->shape, (*rightColP)->shape);
                 continue;
             }
-            vsFunc(play, colChkCtx, *left, *right);
+            vsFunc(play, colChkCtx, *leftColP, *rightColP);
         }
     }
 }
@@ -2951,28 +3034,28 @@ void CollisionCheck_SetInfoGetDamageTable(CollisionCheckInfo* info, s32 index, C
 /**
  * Apply AC damage effect
  */
-void CollisionCheck_ApplyDamage(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider,
-                                ColliderInfo* info) {
+void CollisionCheck_ApplyDamage(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col,
+                                ColliderElement* elem) {
     DamageTable* tbl;
     f32 damage;
 
-    if (collider->actor == NULL || !(collider->acFlags & AC_HIT)) {
+    if (col->actor == NULL || !(col->acFlags & AC_HIT)) {
         return;
     }
-    if (!(info->bumperFlags & BUMP_HIT) || info->bumperFlags & BUMP_NO_DAMAGE) {
+    if (!(elem->bumperFlags & BUMP_HIT) || elem->bumperFlags & BUMP_NO_DAMAGE) {
         return;
     }
 
-    ASSERT(info->acHitInfo != NULL, "pclobj_elem->ac_hit_elem != NULL", "../z_collision_check.c", 6493);
-    tbl = collider->actor->colChkInfo.damageTable;
+    ASSERT(elem->acHitElem != NULL, "pclobj_elem->ac_hit_elem != NULL", "../z_collision_check.c", 6493);
+    tbl = col->actor->colChkInfo.damageTable;
     if (tbl == NULL) {
-        damage = (f32)info->acHitInfo->toucher.damage - info->bumper.defense;
+        damage = (f32)elem->acHitElem->toucher.damage - elem->bumper.defense;
         if (damage < 0) {
             damage = 0;
         }
     } else {
         s32 i;
-        u32 flags = info->acHitInfo->toucher.dmgFlags;
+        u32 flags = elem->acHitElem->toucher.dmgFlags;
 
         for (i = 0; i < 32; i++, flags >>= 1) {
             if (flags == 1) {
@@ -2981,23 +3064,23 @@ void CollisionCheck_ApplyDamage(PlayState* play, CollisionCheckContext* colChkCt
         }
 
         damage = tbl->table[i] & 0xF;
-        collider->actor->colChkInfo.damageEffect = tbl->table[i] >> 4 & 0xF;
+        col->actor->colChkInfo.damageEffect = tbl->table[i] >> 4 & 0xF;
     }
-    if (!(collider->acFlags & AC_HARD)) {
-        collider->actor->colChkInfo.damage += damage;
+    if (!(col->acFlags & AC_HARD)) {
+        col->actor->colChkInfo.damage += damage;
     }
 }
 
 /**
  * Apply ColliderJntSph AC damage effect
  */
-void CollisionCheck_ApplyDamageJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider) {
-    ColliderJntSph* jntSph = (ColliderJntSph*)collider;
+void CollisionCheck_ApplyDamageJntSph(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
+    ColliderJntSph* jntSph = (ColliderJntSph*)col;
     s32 i;
 
     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);
         }
     }
 }
@@ -3005,29 +3088,31 @@ void CollisionCheck_ApplyDamageJntSph(PlayState* play, CollisionCheckContext* co
 /**
  * Apply ColliderCylinder AC damage effect
  */
-void CollisionCheck_ApplyDamageCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider) {
-    ColliderCylinder* cylinder = (ColliderCylinder*)collider;
-    CollisionCheck_ApplyDamage(play, colChkCtx, &cylinder->base, &cylinder->info);
+void CollisionCheck_ApplyDamageCyl(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
+    ColliderCylinder* cyl = (ColliderCylinder*)col;
+
+    CollisionCheck_ApplyDamage(play, colChkCtx, &cyl->base, &cyl->elem);
 }
 
 /**
  * Apply ColliderTris AC damage effect
  */
-void CollisionCheck_ApplyDamageTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider) {
-    ColliderTris* tris = (ColliderTris*)collider;
+void CollisionCheck_ApplyDamageTris(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
+    ColliderTris* tris = (ColliderTris*)col;
     s32 i;
 
     for (i = 0; i < tris->count; i++) {
-        CollisionCheck_ApplyDamage(play, colChkCtx, collider, &tris->elements[i].info);
+        CollisionCheck_ApplyDamage(play, colChkCtx, col, &tris->elements[i].base);
     }
 }
 
 /**
  *  Apply ColliderQuad AC damage effect
  */
-void CollisionCheck_ApplyDamageQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* collider) {
-    ColliderQuad* quad = (ColliderQuad*)collider;
-    CollisionCheck_ApplyDamage(play, colChkCtx, &quad->base, &quad->info);
+void CollisionCheck_ApplyDamageQuad(PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
+    ColliderQuad* quad = (ColliderQuad*)col;
+
+    CollisionCheck_ApplyDamage(play, colChkCtx, &quad->base, &quad->elem);
 }
 
 static ColChkApplyFunc sApplyDamageFuncs[COLSHAPE_MAX] = {
@@ -3045,15 +3130,15 @@ void CollisionCheck_Damage(PlayState* play, CollisionCheckContext* colChkCtx) {
     s32 i;
 
     for (i = 0; i < colChkCtx->colACCount; i++) {
-        Collider* collider = colChkCtx->colAC[i];
+        Collider* col = colChkCtx->colAC[i];
 
-        if (collider == NULL) {
+        if (col == NULL) {
             continue;
         }
-        if (collider->acFlags & AC_NO_DAMAGE) {
+        if (col->acFlags & AC_NO_DAMAGE) {
             continue;
         }
-        sApplyDamageFuncs[collider->shape](play, colChkCtx, collider);
+        sApplyDamageFuncs[col->shape](play, colChkCtx, col);
     }
 }
 
@@ -3069,7 +3154,7 @@ s32 CollisionCheck_LineOC_JntSph(PlayState* play, CollisionCheckContext* colChkC
     for (i = 0; i < jntSph->count; i++) {
         ColliderJntSphElement* element = &jntSph->elements[i];
 
-        if (!(element->info.ocElemFlags & OCELEM_ON)) {
+        if (!(element->base.ocElemFlags & OCELEM_ON)) {
             continue;
         }
         lineSeg.a = *a;
@@ -3090,7 +3175,7 @@ s32 CollisionCheck_LineOC_Cyl(PlayState* play, CollisionCheckContext* colChkCtx,
     static Vec3f intersectB;
     ColliderCylinder* cylinder = (ColliderCylinder*)collider;
 
-    if (!(cylinder->info.ocElemFlags & OCELEM_ON)) {
+    if (!(cylinder->elem.ocElemFlags & OCELEM_ON)) {
         return false;
     }
     if (Math3D_CylVsLineSeg(&cylinder->dim, a, b, &intersectA, &intersectB) != 0) {
@@ -3166,59 +3251,59 @@ s32 CollisionCheck_LineOCCheck(PlayState* play, CollisionCheckContext* colChkCtx
 /**
  * Moves the ColliderCylinder's position to the actor's position
  */
-void Collider_UpdateCylinder(Actor* actor, ColliderCylinder* collider) {
-    collider->dim.pos.x = actor->world.pos.x;
-    collider->dim.pos.y = actor->world.pos.y;
-    collider->dim.pos.z = actor->world.pos.z;
+void Collider_UpdateCylinder(Actor* actor, ColliderCylinder* cyl) {
+    cyl->dim.pos.x = actor->world.pos.x;
+    cyl->dim.pos.y = actor->world.pos.y;
+    cyl->dim.pos.z = actor->world.pos.z;
 }
 
 /**
  * Sets the ColliderCylinder's position
  */
-void Collider_SetCylinderPosition(ColliderCylinder* collider, Vec3s* pos) {
-    collider->dim.pos.x = pos->x;
-    collider->dim.pos.y = pos->y;
-    collider->dim.pos.z = pos->z;
+void Collider_SetCylinderPosition(ColliderCylinder* cyl, Vec3s* pos) {
+    cyl->dim.pos.x = pos->x;
+    cyl->dim.pos.y = pos->y;
+    cyl->dim.pos.z = pos->z;
 }
 
 /**
  * Sets the ColliderQuad's vertices
  */
-void Collider_SetQuadVertices(ColliderQuad* collider, Vec3f* a, Vec3f* b, Vec3f* c, Vec3f* d) {
-    Math_Vec3f_Copy(&collider->dim.quad[2], c);
-    Math_Vec3f_Copy(&collider->dim.quad[3], d);
-    Math_Vec3f_Copy(&collider->dim.quad[0], a);
-    Math_Vec3f_Copy(&collider->dim.quad[1], b);
-    Collider_SetQuadMidpoints(&collider->dim);
+void Collider_SetQuadVertices(ColliderQuad* quad, Vec3f* a, Vec3f* b, Vec3f* c, Vec3f* d) {
+    Math_Vec3f_Copy(&quad->dim.quad[2], c);
+    Math_Vec3f_Copy(&quad->dim.quad[3], d);
+    Math_Vec3f_Copy(&quad->dim.quad[0], a);
+    Math_Vec3f_Copy(&quad->dim.quad[1], b);
+    Collider_SetQuadMidpoints(&quad->dim);
 }
 
 /**
  * Sets the specified ColliderTrisElement's vertices
  */
-void Collider_SetTrisVertices(ColliderTris* collider, s32 index, Vec3f* a, Vec3f* b, Vec3f* c) {
-    ColliderTrisElement* element = &collider->elements[index];
+void Collider_SetTrisVertices(ColliderTris* tris, s32 elemIndex, Vec3f* a, Vec3f* b, Vec3f* c) {
+    ColliderTrisElement* trisElem = &tris->elements[elemIndex];
     f32 nx;
     f32 ny;
     f32 nz;
     f32 originDist;
 
-    Math_Vec3f_Copy(&element->dim.vtx[0], a);
-    Math_Vec3f_Copy(&element->dim.vtx[1], b);
-    Math_Vec3f_Copy(&element->dim.vtx[2], c);
+    Math_Vec3f_Copy(&trisElem->dim.vtx[0], a);
+    Math_Vec3f_Copy(&trisElem->dim.vtx[1], b);
+    Math_Vec3f_Copy(&trisElem->dim.vtx[2], c);
     Math3D_DefPlane(a, b, c, &nx, &ny, &nz, &originDist);
-    element->dim.plane.normal.x = nx;
-    element->dim.plane.normal.y = ny;
-    element->dim.plane.normal.z = nz;
-    element->dim.plane.originDist = originDist;
+    trisElem->dim.plane.normal.x = nx;
+    trisElem->dim.plane.normal.y = ny;
+    trisElem->dim.plane.normal.z = nz;
+    trisElem->dim.plane.originDist = originDist;
 }
 
 /**
  * Sets the specified ColliderTrisElement's dim using the values in src
  */
-void Collider_SetTrisDim(PlayState* play, ColliderTris* collider, s32 index, ColliderTrisElementDimInit* src) {
-    ColliderTrisElement* element = &collider->elements[index];
+void Collider_SetTrisDim(PlayState* play, ColliderTris* tris, s32 elemIndex, ColliderTrisElementDimInit* src) {
+    ColliderTrisElement* trisElem = &tris->elements[elemIndex];
 
-    Collider_SetTrisElementDim(play, &element->dim, src);
+    Collider_SetTrisElementDim(play, &trisElem->dim, src);
 }
 
 // Due to an unknown reason, bss ordering changed between the 2 static Vec3f variables in the function below.
@@ -3231,22 +3316,22 @@ static s8 sBssDummy12;
 /**
  * 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 modelPos;
     static Vec3f worldPos; // bss ordering changes here
     s32 i;
 
-    for (i = 0; i < collider->count; i++) {
-        if (limb == collider->elements[i].dim.limb) {
-            modelPos.x = collider->elements[i].dim.modelSphere.center.x;
-            modelPos.y = collider->elements[i].dim.modelSphere.center.y;
-            modelPos.z = collider->elements[i].dim.modelSphere.center.z;
+    for (i = 0; i < jntSph->count; i++) {
+        if (limb == jntSph->elements[i].dim.limb) {
+            modelPos.x = jntSph->elements[i].dim.modelSphere.center.x;
+            modelPos.y = jntSph->elements[i].dim.modelSphere.center.y;
+            modelPos.z = jntSph->elements[i].dim.modelSphere.center.z;
             Matrix_MultVec3f(&modelPos, &worldPos);
-            collider->elements[i].dim.worldSphere.center.x = worldPos.x;
-            collider->elements[i].dim.worldSphere.center.y = worldPos.y;
-            collider->elements[i].dim.worldSphere.center.z = worldPos.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 = worldPos.x;
+            jntSph->elements[i].dim.worldSphere.center.y = worldPos.y;
+            jntSph->elements[i].dim.worldSphere.center.z = worldPos.z;
+            jntSph->elements[i].dim.worldSphere.radius =
+                jntSph->elements[i].dim.modelSphere.radius * jntSph->elements[i].dim.scale;
         }
     }
 }
diff --git a/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c b/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
index 9bc3193e55..5b1e963064 100644
--- a/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
+++ b/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
@@ -169,10 +169,10 @@ void ArmsHook_Shoot(ArmsHook* this, PlayState* play) {
     ArmsHook_CheckForCancel(this);
 
     if ((this->timer != 0) && (this->collider.base.atFlags & AT_HIT) &&
-        (this->collider.info.atHitInfo->elemType != ELEMTYPE_UNK4)) {
+        (this->collider.elem.atHitElem->elemType != ELEMTYPE_UNK4)) {
         touchedActor = this->collider.base.at;
         if ((touchedActor->update != NULL) && (touchedActor->flags & (ACTOR_FLAG_9 | ACTOR_FLAG_10))) {
-            if (this->collider.info.atHitInfo->bumperFlags & BUMP_HOOKABLE) {
+            if (this->collider.elem.atHitElem->bumperFlags & BUMP_HOOKABLE) {
                 ArmsHook_AttachHookToActor(this, touchedActor);
                 if (CHECK_FLAG_ALL(touchedActor->flags, ACTOR_FLAG_10)) {
                     func_80865044(this);
diff --git a/src/overlays/actors/ovl_Bg_Haka_Trap/z_bg_haka_trap.c b/src/overlays/actors/ovl_Bg_Haka_Trap/z_bg_haka_trap.c
index 50fe918853..1e205a090f 100644
--- a/src/overlays/actors/ovl_Bg_Haka_Trap/z_bg_haka_trap.c
+++ b/src/overlays/actors/ovl_Bg_Haka_Trap/z_bg_haka_trap.c
@@ -166,8 +166,8 @@ void BgHakaTrap_Init(Actor* thisx, PlayState* play) {
                 this->colliderCylinder.dim.radius = 18;
                 this->colliderCylinder.dim.height = 115;
 
-                this->colliderCylinder.info.toucherFlags &= ~TOUCH_SFX_NORMAL;
-                this->colliderCylinder.info.toucherFlags |= TOUCH_SFX_WOOD;
+                this->colliderCylinder.elem.toucherFlags &= ~TOUCH_SFX_NORMAL;
+                this->colliderCylinder.elem.toucherFlags |= TOUCH_SFX_WOOD;
 
                 this->actionFunc = func_808801B8;
             }
diff --git a/src/overlays/actors/ovl_Bg_Haka_Tubo/z_bg_haka_tubo.c b/src/overlays/actors/ovl_Bg_Haka_Tubo/z_bg_haka_tubo.c
index fe97e4920b..fbc49da85c 100644
--- a/src/overlays/actors/ovl_Bg_Haka_Tubo/z_bg_haka_tubo.c
+++ b/src/overlays/actors/ovl_Bg_Haka_Tubo/z_bg_haka_tubo.c
@@ -116,7 +116,7 @@ void BgHakaTubo_Idle(BgHakaTubo* this, PlayState* play) {
         this->flamesCollider.base.atFlags &= ~AT_HIT;
         func_8002F71C(play, &this->dyna.actor, 5.0f, this->dyna.actor.yawTowardsPlayer, 5.0f);
     }
-    // Colliding with hitbox inside the pot
+    // Colliding with collider inside the pot
     if (this->potCollider.base.acFlags & AC_HIT) {
         this->potCollider.base.acFlags &= ~AC_HIT;
         // If the colliding actor is within a 50 unit radius and 50 unit height cylinder centered
diff --git a/src/overlays/actors/ovl_Bg_Hidan_Dalm/z_bg_hidan_dalm.c b/src/overlays/actors/ovl_Bg_Hidan_Dalm/z_bg_hidan_dalm.c
index 9083889ad0..5d91381a97 100644
--- a/src/overlays/actors/ovl_Bg_Hidan_Dalm/z_bg_hidan_dalm.c
+++ b/src/overlays/actors/ovl_Bg_Hidan_Dalm/z_bg_hidan_dalm.c
@@ -129,8 +129,8 @@ void BgHidanDalm_Wait(BgHidanDalm* this, PlayState* play) {
         (player->meleeWeaponAnimation == PLAYER_MWA_HAMMER_FORWARD ||
          player->meleeWeaponAnimation == PLAYER_MWA_HAMMER_SIDE)) {
         this->collider.base.acFlags &= ~AC_HIT;
-        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->dyna.actor.world.rot.y -= 0x4000;
         } else {
             this->dyna.actor.world.rot.y += 0x4000;
diff --git a/src/overlays/actors/ovl_Bg_Hidan_Sekizou/z_bg_hidan_sekizou.c b/src/overlays/actors/ovl_Bg_Hidan_Sekizou/z_bg_hidan_sekizou.c
index d63aae1863..0e0f1f6062 100644
--- a/src/overlays/actors/ovl_Bg_Hidan_Sekizou/z_bg_hidan_sekizou.c
+++ b/src/overlays/actors/ovl_Bg_Hidan_Sekizou/z_bg_hidan_sekizou.c
@@ -139,8 +139,8 @@ void func_8088CEC0(BgHidanSekizou* this, s32 arg1, s16 arg2) {
         element->dim.worldSphere.center.y = (s16)this->dyna.actor.home.pos.y + element->dim.modelSphere.center.y;
         element->dim.worldSphere.center.z = this->dyna.actor.home.pos.z - (sp30 * element->dim.modelSphere.center.x) +
                                             (sp2C * element->dim.modelSphere.center.z);
-        element->info.toucherFlags |= TOUCH_ON;
-        element->info.ocElemFlags |= OCELEM_ON;
+        element->base.toucherFlags |= TOUCH_ON;
+        element->base.ocElemFlags |= OCELEM_ON;
     }
 }
 
@@ -210,8 +210,8 @@ void func_8088D434(BgHidanSekizou* this, PlayState* play) {
         }
     }
     for (i = 3 * phi_s4; i < ARRAY_COUNT(this->elements); i++) {
-        this->collider.elements[i].info.toucherFlags &= ~TOUCH_ON;
-        this->collider.elements[i].info.ocElemFlags &= ~OCELEM_ON;
+        this->collider.elements[i].base.toucherFlags &= ~TOUCH_ON;
+        this->collider.elements[i].base.ocElemFlags &= ~OCELEM_ON;
     }
 }
 
diff --git a/src/overlays/actors/ovl_Boss_Dodongo/z_boss_dodongo.c b/src/overlays/actors/ovl_Boss_Dodongo/z_boss_dodongo.c
index da6014559f..632faf17e3 100644
--- a/src/overlays/actors/ovl_Boss_Dodongo/z_boss_dodongo.c
+++ b/src/overlays/actors/ovl_Boss_Dodongo/z_boss_dodongo.c
@@ -1225,7 +1225,7 @@ void BossDodongo_SpawnFire(BossDodongo* this, PlayState* play, s16 params) {
 
 void BossDodongo_UpdateDamage(BossDodongo* this, PlayState* play) {
     s32 pad;
-    ColliderInfo* item;
+    ColliderElement* acHitElem;
     u8 swordDamage;
     s32 damage;
     s16 i;
@@ -1239,11 +1239,12 @@ void BossDodongo_UpdateDamage(BossDodongo* this, PlayState* play) {
     if (this->unk_1C0 == 0) {
         if (this->actionFunc == BossDodongo_Inhale) {
             for (i = 0; i < 19; i++) {
-                if (this->collider.elements[i].info.bumperFlags & BUMP_HIT) {
-                    item = this->collider.elements[i].info.acHitInfo;
+                if (this->collider.elements[i].base.bumperFlags & BUMP_HIT) {
+                    acHitElem = this->collider.elements[i].base.acHitElem;
 
-                    if ((item->toucher.dmgFlags & DMG_BOOMERANG) || (item->toucher.dmgFlags & DMG_SLINGSHOT)) {
-                        this->collider.elements[i].info.bumperFlags &= ~BUMP_HIT;
+                    if ((acHitElem->toucher.dmgFlags & DMG_BOOMERANG) ||
+                        (acHitElem->toucher.dmgFlags & DMG_SLINGSHOT)) {
+                        this->collider.elements[i].base.bumperFlags &= ~BUMP_HIT;
                         this->unk_1C0 = 2;
                         BossDodongo_SetupWalk(this);
                         this->unk_1DA = 0x32;
@@ -1253,11 +1254,11 @@ void BossDodongo_UpdateDamage(BossDodongo* this, PlayState* play) {
             }
         }
 
-        if (this->collider.elements->info.bumperFlags & BUMP_HIT) {
-            this->collider.elements->info.bumperFlags &= ~BUMP_HIT;
-            item = this->collider.elements[0].info.acHitInfo;
+        if (this->collider.elements[0].base.bumperFlags & BUMP_HIT) {
+            this->collider.elements[0].base.bumperFlags &= ~BUMP_HIT;
+            acHitElem = this->collider.elements[0].base.acHitElem;
             if ((this->actionFunc == BossDodongo_Vulnerable) || (this->actionFunc == BossDodongo_LayDown)) {
-                swordDamage = damage = CollisionCheck_GetSwordDamage(item->toucher.dmgFlags);
+                swordDamage = damage = CollisionCheck_GetSwordDamage(acHitElem->toucher.dmgFlags);
 
                 if (damage != 0) {
                     Actor_PlaySfx(&this->actor, NA_SE_EN_DODO_K_DAMAGE);
diff --git a/src/overlays/actors/ovl_Boss_Fd/z_boss_fd.c b/src/overlays/actors/ovl_Boss_Fd/z_boss_fd.c
index 4b90a2a155..ba53be91b8 100644
--- a/src/overlays/actors/ovl_Boss_Fd/z_boss_fd.c
+++ b/src/overlays/actors/ovl_Boss_Fd/z_boss_fd.c
@@ -1279,13 +1279,13 @@ void BossFd_Effects(BossFd* this, PlayState* play) {
 
 void BossFd_CollisionCheck(BossFd* this, PlayState* play) {
     ColliderJntSphElement* headCollider = &this->collider.elements[0];
-    ColliderInfo* hurtbox;
+    ColliderElement* acHitElem;
 
-    if (headCollider->info.bumperFlags & BUMP_HIT) {
-        headCollider->info.bumperFlags &= ~BUMP_HIT;
-        hurtbox = headCollider->info.acHitInfo;
+    if (headCollider->base.bumperFlags & BUMP_HIT) {
+        headCollider->base.bumperFlags &= ~BUMP_HIT;
+        acHitElem = headCollider->base.acHitElem;
         this->actor.colChkInfo.health -= 2;
-        if (hurtbox->toucher.dmgFlags & DMG_ARROW_ICE) {
+        if (acHitElem->toucher.dmgFlags & DMG_ARROW_ICE) {
             this->actor.colChkInfo.health -= 2;
         }
         if ((s8)this->actor.colChkInfo.health <= 2) {
diff --git a/src/overlays/actors/ovl_Boss_Fd2/z_boss_fd2.c b/src/overlays/actors/ovl_Boss_Fd2/z_boss_fd2.c
index eaf0b9daa8..9734713553 100644
--- a/src/overlays/actors/ovl_Boss_Fd2/z_boss_fd2.c
+++ b/src/overlays/actors/ovl_Boss_Fd2/z_boss_fd2.c
@@ -806,33 +806,33 @@ void BossFd2_Wait(BossFd2* this, PlayState* play) {
 
 void BossFd2_CollisionCheck(BossFd2* this, PlayState* play) {
     s16 i;
-    ColliderInfo* hurtbox;
+    ColliderElement* acHitElem;
     BossFd* bossFd = (BossFd*)this->actor.parent;
 
     if (this->actionFunc == BossFd2_ClawSwipe) {
         Player* player = GET_PLAYER(play);
 
         for (i = 0; i < ARRAY_COUNT(this->elements); i++) {
-            if (this->collider.elements[i].info.toucherFlags & TOUCH_HIT) {
-                this->collider.elements[i].info.toucherFlags &= ~TOUCH_HIT;
+            if (this->collider.elements[i].base.toucherFlags & TOUCH_HIT) {
+                this->collider.elements[i].base.toucherFlags &= ~TOUCH_HIT;
                 Actor_PlaySfx(&player->actor, NA_SE_PL_BODY_HIT);
             }
         }
     }
     if (!bossFd->faceExposed) {
-        this->collider.elements[0].info.elemType = ELEMTYPE_UNK2;
+        this->collider.elements[0].base.elemType = ELEMTYPE_UNK2;
         this->collider.base.colType = COLTYPE_METAL;
     } else {
-        this->collider.elements[0].info.elemType = ELEMTYPE_UNK3;
+        this->collider.elements[0].base.elemType = ELEMTYPE_UNK3;
         this->collider.base.colType = COLTYPE_HIT3;
     }
 
-    if (this->collider.elements[0].info.bumperFlags & BUMP_HIT) {
-        this->collider.elements[0].info.bumperFlags &= ~BUMP_HIT;
+    if (this->collider.elements[0].base.bumperFlags & BUMP_HIT) {
+        this->collider.elements[0].base.bumperFlags &= ~BUMP_HIT;
 
-        hurtbox = this->collider.elements[0].info.acHitInfo;
+        acHitElem = this->collider.elements[0].base.acHitElem;
         if (!bossFd->faceExposed) {
-            if (hurtbox->toucher.dmgFlags & DMG_HAMMER) {
+            if (acHitElem->toucher.dmgFlags & DMG_HAMMER) {
                 bossFd->actor.colChkInfo.health -= 2;
                 if ((s8)bossFd->actor.colChkInfo.health <= 2) {
                     bossFd->actor.colChkInfo.health = 1;
@@ -863,12 +863,12 @@ void BossFd2_CollisionCheck(BossFd2* this, PlayState* play) {
             u8 canKill = false;
             u8 damage;
 
-            if ((damage = CollisionCheck_GetSwordDamage(hurtbox->toucher.dmgFlags)) == 0) {
-                damage = (hurtbox->toucher.dmgFlags & DMG_ARROW_ICE) ? 4 : 2;
+            if ((damage = CollisionCheck_GetSwordDamage(acHitElem->toucher.dmgFlags)) == 0) {
+                damage = (acHitElem->toucher.dmgFlags & DMG_ARROW_ICE) ? 4 : 2;
             } else {
                 canKill = true;
             }
-            if (hurtbox->toucher.dmgFlags & DMG_HOOKSHOT) {
+            if (acHitElem->toucher.dmgFlags & DMG_HOOKSHOT) {
                 damage = 0;
             }
             if (((s8)bossFd->actor.colChkInfo.health > 2) || canKill) {
diff --git a/src/overlays/actors/ovl_Boss_Ganon/z_boss_ganon.c b/src/overlays/actors/ovl_Boss_Ganon/z_boss_ganon.c
index 4767bdcbe4..0e401ef752 100644
--- a/src/overlays/actors/ovl_Boss_Ganon/z_boss_ganon.c
+++ b/src/overlays/actors/ovl_Boss_Ganon/z_boss_ganon.c
@@ -2681,22 +2681,22 @@ void BossGanon_Damaged(BossGanon* this, PlayState* play) {
 void BossGanon_UpdateDamage(BossGanon* this, PlayState* play) {
     s16 i;
     s16 j;
-    ColliderInfo* acHitInfo;
+    ColliderElement* acHitElem;
 
     if (this->collider.base.acFlags & AC_HIT) {
         this->unk_2D4 = 2;
         this->collider.base.acFlags &= ~AC_HIT;
-        acHitInfo = this->collider.info.acHitInfo;
+        acHitElem = this->collider.elem.acHitElem;
 
         if ((this->actionFunc == BossGanon_HitByLightBall) || (this->actionFunc == BossGanon_ChargeBigMagic)) {
-            if (acHitInfo->toucher.dmgFlags & DMG_ARROW_LIGHT) {
+            if (acHitElem->toucher.dmgFlags & DMG_ARROW_LIGHT) {
                 BossGanon_SetupVulnerable(this, play);
                 this->timers[2] = 0;
                 Actor_PlaySfx(&this->actor, NA_SE_EN_GANON_DAMAGE1);
                 this->unk_1A6 = 15;
             }
         } else if ((this->actionFunc == BossGanon_Vulnerable) && (this->unk_1C2 >= 3)) {
-            if (!(acHitInfo->toucher.dmgFlags & DMG_HOOKSHOT)) {
+            if (!(acHitElem->toucher.dmgFlags & DMG_HOOKSHOT)) {
                 u8 hitWithSword = false;
                 u8 damage;
                 Vec3f sp50;
@@ -2710,7 +2710,7 @@ void BossGanon_UpdateDamage(BossGanon* this, PlayState* play) {
                                               0x1E);
                 }
 
-                damage = flags = CollisionCheck_GetSwordDamage(acHitInfo->toucher.dmgFlags);
+                damage = flags = CollisionCheck_GetSwordDamage(acHitElem->toucher.dmgFlags);
 
                 if (flags == 0) {
                     damage = 2;
@@ -2744,7 +2744,7 @@ void BossGanon_UpdateDamage(BossGanon* this, PlayState* play) {
                     sCape->tearTimer = 1;
                 }
             }
-        } else if (acHitInfo->toucher.dmgFlags & DMG_RANGED) {
+        } else if (acHitElem->toucher.dmgFlags & DMG_RANGED) {
             Actor_PlaySfx(&this->actor, 0);
 
             for (i = 0; i < ARRAY_COUNT(sCape->strands); i++) {
@@ -3931,11 +3931,11 @@ void BossGanon_LightBall_Update(Actor* thisx, PlayState* play2) {
                 }
 
                 if ((this->collider.base.acFlags & AC_HIT) || hitWithBottle) {
-                    ColliderInfo* acHitInfo = this->collider.info.acHitInfo;
+                    ColliderElement* acHitElem = this->collider.elem.acHitElem;
 
                     this->collider.base.acFlags &= ~AC_HIT;
 
-                    if ((hitWithBottle == false) && (acHitInfo->toucher.dmgFlags & DMG_SHIELD)) {
+                    if ((hitWithBottle == false) && (acHitElem->toucher.dmgFlags & DMG_SHIELD)) {
                         spBA = 2;
                         Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_REFLECT_MG, &player->actor.projectedPos, 4,
                                              &gSfxDefaultFreqAndVolScale, &gSfxDefaultFreqAndVolScale,
@@ -4305,7 +4305,7 @@ void func_808E2544(Actor* thisx, PlayState* play) {
     BossGanon* dorf = (BossGanon*)this->actor.parent;
     s32 pad;
     Player* player = GET_PLAYER(play);
-    ColliderInfo* acHitInfo;
+    ColliderElement* acHitElem;
     Vec3f sp60;
 
     this->unk_1A2++;
@@ -4415,11 +4415,11 @@ void func_808E2544(Actor* thisx, PlayState* play) {
             }
 
             if (this->collider.base.acFlags & AC_HIT) {
-                acHitInfo = this->collider.info.acHitInfo;
+                acHitElem = this->collider.elem.acHitElem;
 
                 this->collider.base.acFlags &= ~AC_HIT;
 
-                if (!(acHitInfo->toucher.dmgFlags & DMG_SHIELD) || Player_HasMirrorShieldEquipped(play)) {
+                if (!(acHitElem->toucher.dmgFlags & DMG_SHIELD) || Player_HasMirrorShieldEquipped(play)) {
                     Rumble_Request(this->actor.xyzDistToPlayerSq, 180, 20, 100);
                     this->unk_1C2 = 0xC;
                     this->actor.speed = -30.0f;
diff --git a/src/overlays/actors/ovl_Boss_Ganon2/z_boss_ganon2.c b/src/overlays/actors/ovl_Boss_Ganon2/z_boss_ganon2.c
index 2d4e44e740..d03a5206b1 100644
--- a/src/overlays/actors/ovl_Boss_Ganon2/z_boss_ganon2.c
+++ b/src/overlays/actors/ovl_Boss_Ganon2/z_boss_ganon2.c
@@ -1842,10 +1842,10 @@ void func_80902348(BossGanon2* this, PlayState* play) {
 
     if (this->unk_316 == 0) {
         for (i = 0; i < ARRAY_COUNT(this->unk_864); i++) {
-            if (this->unk_444.elements[i].info.bumperFlags & BUMP_HIT) {
-                this->unk_444.elements[i].info.bumperFlags &= ~BUMP_HIT;
-            } else if (this->unk_444.elements[i].info.toucherFlags & TOUCH_HIT) {
-                this->unk_444.elements[i].info.toucherFlags &= ~TOUCH_HIT;
+            if (this->unk_444.elements[i].base.bumperFlags & BUMP_HIT) {
+                this->unk_444.elements[i].base.bumperFlags &= ~BUMP_HIT;
+            } else if (this->unk_444.elements[i].base.toucherFlags & TOUCH_HIT) {
+                this->unk_444.elements[i].base.toucherFlags &= ~TOUCH_HIT;
 
                 if (this->unk_312 == 1) {
                     phi_v0_2 = 0x1800;
@@ -1880,30 +1880,30 @@ void func_80902348(BossGanon2* this, PlayState* play) {
 
 void func_80902524(BossGanon2* this, PlayState* play) {
     s8 temp_v0_4;
-    ColliderInfo* acHitInfo;
+    ColliderElement* acHitElem;
     s16 i;
     u8 phi_v1_2;
 
     osSyncPrintf("this->no_hit_time %d\n", this->unk_316);
     if (this->unk_316 != 0 || ((this->unk_334 == 0) && (this->actionFunc == func_80900890))) {
         for (i = 0; i < ARRAY_COUNT(this->unk_464); i++) {
-            this->unk_424.elements[i].info.bumperFlags &= ~BUMP_HIT;
+            this->unk_424.elements[i].base.bumperFlags &= ~BUMP_HIT;
         }
     }
 
     osSyncPrintf("this->look_on %d\n", this->unk_313);
     if (this->unk_313) {
         if (this->actionFunc != func_808FFFE0) {
-            if (this->unk_424.elements[0].info.bumperFlags & BUMP_HIT) {
-                this->unk_424.elements[0].info.bumperFlags &= ~BUMP_HIT;
-                acHitInfo = this->unk_424.elements[0].info.acHitInfo;
-                if ((acHitInfo->toucher.dmgFlags & DMG_ARROW_LIGHT) && (this->actionFunc != func_80900890)) {
+            if (this->unk_424.elements[0].base.bumperFlags & BUMP_HIT) {
+                this->unk_424.elements[0].base.bumperFlags &= ~BUMP_HIT;
+                acHitElem = this->unk_424.elements[0].base.acHitElem;
+                if ((acHitElem->toucher.dmgFlags & DMG_ARROW_LIGHT) && (this->actionFunc != func_80900890)) {
                     func_809000A0(this, play);
                     Actor_PlaySfx(&this->actor, NA_SE_EN_FANTOM_HIT_THUNDER);
                     Actor_PlaySfx(&this->actor, NA_SE_EN_MGANON_DAMAGE);
                     Audio_StopSfxById(NA_SE_EN_MGANON_UNARI);
                 } else if ((this->actionFunc == func_80900890) &&
-                           (acHitInfo->toucher.dmgFlags & (DMG_JUMP_MASTER | DMG_SPIN_MASTER | DMG_SLASH_MASTER))) {
+                           (acHitElem->toucher.dmgFlags & (DMG_JUMP_MASTER | DMG_SPIN_MASTER | DMG_SLASH_MASTER))) {
                     this->unk_316 = 60;
                     this->unk_342 = 5;
                     Actor_PlaySfx(&this->actor, NA_SE_EN_MGANON_DAMAGE);
@@ -1926,17 +1926,17 @@ void func_80902524(BossGanon2* this, PlayState* play) {
             }
         }
     } else {
-        if (this->unk_424.elements[15].info.bumperFlags & BUMP_HIT) {
-            this->unk_424.elements[15].info.bumperFlags &= ~BUMP_HIT;
-            acHitInfo = this->unk_424.elements[15].info.acHitInfo;
+        if (this->unk_424.elements[15].base.bumperFlags & BUMP_HIT) {
+            this->unk_424.elements[15].base.bumperFlags &= ~BUMP_HIT;
+            acHitElem = this->unk_424.elements[15].base.acHitElem;
             this->unk_316 = 60;
             this->unk_344 = 0x32;
             this->unk_342 = 5;
             Actor_PlaySfx(&this->actor, NA_SE_EN_MGANON_DAMAGE);
             Audio_StopSfxById(NA_SE_EN_MGANON_UNARI);
             phi_v1_2 = 1;
-            if (acHitInfo->toucher.dmgFlags & (DMG_JUMP_MASTER | DMG_SPIN_MASTER | DMG_SLASH_MASTER)) {
-                if (acHitInfo->toucher.dmgFlags & DMG_JUMP_MASTER) {
+            if (acHitElem->toucher.dmgFlags & (DMG_JUMP_MASTER | DMG_SPIN_MASTER | DMG_SLASH_MASTER)) {
+                if (acHitElem->toucher.dmgFlags & DMG_JUMP_MASTER) {
                     phi_v1_2 = 4;
                 } else {
                     phi_v1_2 = 2;
diff --git a/src/overlays/actors/ovl_Boss_Ganondrof/z_boss_ganondrof.c b/src/overlays/actors/ovl_Boss_Ganondrof/z_boss_ganondrof.c
index 3591b810cc..fbf301f2cb 100644
--- a/src/overlays/actors/ovl_Boss_Ganondrof/z_boss_ganondrof.c
+++ b/src/overlays/actors/ovl_Boss_Ganondrof/z_boss_ganondrof.c
@@ -1224,7 +1224,7 @@ void BossGanondrof_Death(BossGanondrof* this, PlayState* play) {
 void BossGanondrof_CollisionCheck(BossGanondrof* this, PlayState* play) {
     s32 acHit;
     EnfHG* horse = (EnfHG*)this->actor.child;
-    ColliderInfo* hurtbox;
+    ColliderElement* acHitElem;
 
     if (this->work[GND_INVINC_TIMER] != 0) {
         this->work[GND_INVINC_TIMER]--;
@@ -1235,17 +1235,18 @@ void BossGanondrof_CollisionCheck(BossGanondrof* this, PlayState* play) {
         if ((acHit && ((s8)this->actor.colChkInfo.health > 0)) || (this->returnCount != 0)) {
             if (acHit) {
                 this->colliderBody.base.acFlags &= ~AC_HIT;
-                hurtbox = this->colliderBody.info.acHitInfo;
+                acHitElem = this->colliderBody.elem.acHitElem;
             }
             if (this->flyMode != GND_FLY_PAINTING) {
-                if (acHit && (this->actionFunc != BossGanondrof_Stunned) && (hurtbox->toucher.dmgFlags & DMG_RANGED)) {
+                if (acHit && (this->actionFunc != BossGanondrof_Stunned) &&
+                    (acHitElem->toucher.dmgFlags & DMG_RANGED)) {
                     Actor_PlaySfx(&this->actor, NA_SE_NONE);
                     osSyncPrintf("hit != 0 \n");
                 } else if (this->actionFunc != BossGanondrof_Charge) {
                     if (this->returnCount == 0) {
                         u8 dmg;
                         u8 canKill = false;
-                        s32 dmgFlags = hurtbox->toucher.dmgFlags;
+                        s32 dmgFlags = acHitElem->toucher.dmgFlags;
 
                         if (dmgFlags & DMG_HOOKSHOT) {
                             return;
@@ -1272,7 +1273,7 @@ void BossGanondrof_CollisionCheck(BossGanondrof* this, PlayState* play) {
                 } else {
                     Actor_PlaySfx(&this->actor, NA_SE_NONE);
                 }
-            } else if (acHit && (hurtbox->toucher.dmgFlags & DMG_RANGED)) {
+            } else if (acHit && (acHitElem->toucher.dmgFlags & DMG_RANGED)) {
                 this->work[GND_INVINC_TIMER] = 10;
                 this->actor.colChkInfo.health -= 2;
                 horse->hitTimer = 20;
diff --git a/src/overlays/actors/ovl_Boss_Goma/z_boss_goma.c b/src/overlays/actors/ovl_Boss_Goma/z_boss_goma.c
index a7d7a885d7..d247c6acc0 100644
--- a/src/overlays/actors/ovl_Boss_Goma/z_boss_goma.c
+++ b/src/overlays/actors/ovl_Boss_Goma/z_boss_goma.c
@@ -1301,7 +1301,7 @@ void BossGoma_FloorAttack(BossGoma* this, PlayState* play) {
     switch (this->actionState) {
         case 0:
             for (i = 0; i < this->collider.count; i++) {
-                if (this->collider.elements[i].info.toucherFlags & TOUCH_HIT) {
+                if (this->collider.elements[i].base.toucherFlags & TOUCH_HIT) {
                     this->framesUntilNextAction = 10;
                     break;
                 }
@@ -1807,19 +1807,19 @@ void BossGoma_UpdateHit(BossGoma* this, PlayState* play) {
     if (this->invincibilityFrames != 0) {
         this->invincibilityFrames--;
     } else {
-        ColliderInfo* acHitInfo = this->collider.elements[0].info.acHitInfo;
+        ColliderElement* acHitElem = this->collider.elements[0].base.acHitElem;
         s32 damage;
 
         if (this->eyeClosedTimer == 0 && this->actionFunc != BossGoma_CeilingSpawnGohmas &&
-            (this->collider.elements[0].info.bumperFlags & BUMP_HIT)) {
-            this->collider.elements[0].info.bumperFlags &= ~BUMP_HIT;
+            (this->collider.elements[0].base.bumperFlags & BUMP_HIT)) {
+            this->collider.elements[0].base.bumperFlags &= ~BUMP_HIT;
 
             if (this->actionFunc == BossGoma_CeilingMoveToCenter || this->actionFunc == BossGoma_CeilingIdle ||
                 this->actionFunc == BossGoma_CeilingPrepareSpawnGohmas) {
                 BossGoma_SetupFallStruckDown(this);
                 Actor_PlaySfx(&this->actor, NA_SE_EN_GOMA_DAM2);
             } else if (this->actionFunc == BossGoma_FloorStunned &&
-                       (damage = CollisionCheck_GetSwordDamage(acHitInfo->toucher.dmgFlags)) != 0) {
+                       (damage = CollisionCheck_GetSwordDamage(acHitElem->toucher.dmgFlags)) != 0) {
                 this->actor.colChkInfo.health -= damage;
 
                 if ((s8)this->actor.colChkInfo.health > 0) {
@@ -1833,14 +1833,14 @@ void BossGoma_UpdateHit(BossGoma* this, PlayState* play) {
 
                 this->invincibilityFrames = 10;
             } else if (this->actionFunc != BossGoma_FloorStunned && this->patienceTimer != 0 &&
-                       (acHitInfo->toucher.dmgFlags & (DMG_SLINGSHOT | DMG_DEKU_NUT))) {
+                       (acHitElem->toucher.dmgFlags & (DMG_SLINGSHOT | DMG_DEKU_NUT))) {
                 Actor_PlaySfx(&this->actor, NA_SE_EN_GOMA_DAM2);
                 Audio_StopSfxById(NA_SE_EN_GOMA_CRY1);
                 this->invincibilityFrames = 10;
                 BossGoma_SetupFloorStunned(this);
                 this->sfxFaintTimer = 100;
 
-                if (acHitInfo->toucher.dmgFlags & DMG_DEKU_NUT) {
+                if (acHitElem->toucher.dmgFlags & DMG_DEKU_NUT) {
                     this->framesUntilNextAction = 40;
                 } else {
                     this->framesUntilNextAction = 90;
diff --git a/src/overlays/actors/ovl_Boss_Mo/z_boss_mo.c b/src/overlays/actors/ovl_Boss_Mo/z_boss_mo.c
index 17895effd5..40788a433d 100644
--- a/src/overlays/actors/ovl_Boss_Mo/z_boss_mo.c
+++ b/src/overlays/actors/ovl_Boss_Mo/z_boss_mo.c
@@ -1139,25 +1139,25 @@ void BossMo_TentCollisionCheck(BossMo* this, PlayState* play) {
     s16 i1;
 
     for (i1 = 0; i1 < ARRAY_COUNT(this->tentElements); i1++) {
-        if (this->tentCollider.elements[i1].info.bumperFlags & BUMP_HIT) {
+        if (this->tentCollider.elements[i1].base.bumperFlags & BUMP_HIT) {
             s16 i2;
-            ColliderInfo* hurtbox;
+            ColliderElement* acHitElem;
 
             for (i2 = 0; i2 < 19; i2++) {
-                this->tentCollider.elements[i2].info.bumperFlags &= ~BUMP_HIT;
-                this->tentCollider.elements[i2].info.toucherFlags &= ~TOUCH_HIT;
+                this->tentCollider.elements[i2].base.bumperFlags &= ~BUMP_HIT;
+                this->tentCollider.elements[i2].base.toucherFlags &= ~TOUCH_HIT;
             }
-            hurtbox = this->tentCollider.elements[i1].info.acHitInfo;
+            acHitElem = this->tentCollider.elements[i1].base.acHitElem;
             this->work[MO_TENT_INVINC_TIMER] = 5;
-            if (hurtbox->toucher.dmgFlags & DMG_MAGIC_FIRE) {
+            if (acHitElem->toucher.dmgFlags & DMG_MAGIC_FIRE) {
                 Sfx_PlaySfxAtPos(&this->tentTipPos, NA_SE_EN_MOFER_CUT);
                 this->cutIndex = 15;
                 this->meltIndex = this->cutIndex + 1;
                 this->work[MO_TENT_ACTION_STATE] = MO_TENT_CUT;
                 this->timers[0] = 40;
                 this->cutScale = 1.0f;
-            } else if (hurtbox->toucher.dmgFlags & (DMG_JUMP_MASTER | DMG_JUMP_GIANT | DMG_SPIN_MASTER |
-                                                    DMG_SPIN_GIANT | DMG_SLASH_GIANT | DMG_SLASH_MASTER)) {
+            } else if (acHitElem->toucher.dmgFlags & (DMG_JUMP_MASTER | DMG_JUMP_GIANT | DMG_SPIN_MASTER |
+                                                      DMG_SPIN_GIANT | DMG_SLASH_GIANT | DMG_SLASH_MASTER)) {
                 this->playerHitTimer = 5;
             }
             this->tentRippleSize = 0.2f;
@@ -1175,8 +1175,8 @@ void BossMo_TentCollisionCheck(BossMo* this, PlayState* play) {
                                     Rand_ZeroFloat(0.08f) + 0.13f);
             }
             break;
-        } else if (this->tentCollider.elements[i1].info.toucherFlags & TOUCH_HIT) {
-            this->tentCollider.elements[i1].info.toucherFlags &= ~TOUCH_HIT;
+        } else if (this->tentCollider.elements[i1].base.toucherFlags & TOUCH_HIT) {
+            this->tentCollider.elements[i1].base.toucherFlags &= ~TOUCH_HIT;
             this->playerHitTimer = 5;
             break;
         }
@@ -1745,17 +1745,17 @@ void BossMo_CoreCollisionCheck(BossMo* this, PlayState* play) {
         }
     }
     if (this->coreCollider.base.acFlags & AC_HIT) {
-        ColliderInfo* hurtbox = this->coreCollider.info.acHitInfo;
+        ColliderElement* acHitElem = this->coreCollider.elem.acHitElem;
         // "hit!!"
         osSyncPrintf("Core_Damage_check 当り！！\n");
         this->coreCollider.base.acFlags &= ~AC_HIT;
-        if ((hurtbox->toucher.dmgFlags & DMG_MAGIC_FIRE) && (this->work[MO_TENT_ACTION_STATE] == MO_CORE_ATTACK)) {
+        if ((acHitElem->toucher.dmgFlags & DMG_MAGIC_FIRE) && (this->work[MO_TENT_ACTION_STATE] == MO_CORE_ATTACK)) {
             this->work[MO_TENT_ACTION_STATE] = MO_CORE_RETREAT;
         }
         // "hit 2 !!"
         osSyncPrintf("Core_Damage_check 当り 2 ！！\n");
         if ((this->work[MO_TENT_ACTION_STATE] != MO_CORE_UNDERWATER) && (this->work[MO_TENT_INVINC_TIMER] == 0)) {
-            u8 damage = CollisionCheck_GetSwordDamage(hurtbox->toucher.dmgFlags);
+            u8 damage = CollisionCheck_GetSwordDamage(acHitElem->toucher.dmgFlags);
 
             if ((damage != 0) && (this->work[MO_TENT_ACTION_STATE] < MO_CORE_ATTACK)) {
                 // "sword hit !!"
@@ -1793,7 +1793,7 @@ void BossMo_CoreCollisionCheck(BossMo* this, PlayState* play) {
                     }
                 }
                 this->work[MO_TENT_INVINC_TIMER] = 10;
-            } else if (!(hurtbox->toucher.dmgFlags & DMG_SHIELD) && (hurtbox->toucher.dmgFlags & DMG_HOOKSHOT)) {
+            } else if (!(acHitElem->toucher.dmgFlags & DMG_SHIELD) && (acHitElem->toucher.dmgFlags & DMG_HOOKSHOT)) {
                 if (this->work[MO_TENT_ACTION_STATE] >= MO_CORE_ATTACK) {
                     Sfx_PlaySfxAtPos(&sMorphaTent1->tentTipPos, NA_SE_EN_MOFER_CUT);
                     sMorphaTent1->cutIndex = this->work[MO_CORE_POS_IN_TENT];
diff --git a/src/overlays/actors/ovl_Boss_Sst/z_boss_sst.c b/src/overlays/actors/ovl_Boss_Sst/z_boss_sst.c
index dcba2da6b4..ac481ba0c7 100644
--- a/src/overlays/actors/ovl_Boss_Sst/z_boss_sst.c
+++ b/src/overlays/actors/ovl_Boss_Sst/z_boss_sst.c
@@ -870,10 +870,10 @@ void BossSst_HeadStunned(BossSst* this, PlayState* play) {
 void BossSst_HeadSetupVulnerable(BossSst* this) {
     Animation_MorphToLoop(&this->skelAnime, &gBongoHeadStunnedAnim, -5.0f);
     this->colliderCyl.base.acFlags |= AC_ON;
-    this->colliderCyl.info.bumper.dmgFlags = DMG_SWORD | DMG_DEKU_STICK;
+    this->colliderCyl.elem.bumper.dmgFlags = DMG_SWORD | DMG_DEKU_STICK;
     this->actor.speed = 0.0f;
-    this->colliderJntSph.elements[10].info.bumperFlags |= (BUMP_ON | BUMP_HOOKABLE);
-    this->colliderJntSph.elements[0].info.bumperFlags &= ~BUMP_ON;
+    this->colliderJntSph.elements[10].base.bumperFlags |= (BUMP_ON | BUMP_HOOKABLE);
+    this->colliderJntSph.elements[0].base.bumperFlags &= ~BUMP_ON;
     if (this->actionFunc != BossSst_HeadDamage) {
         this->timer = 50;
     }
@@ -929,9 +929,9 @@ void BossSst_HeadDamage(BossSst* this, PlayState* play) {
 void BossSst_HeadSetupRecover(BossSst* this) {
     Animation_MorphToPlayOnce(&this->skelAnime, &gBongoHeadRecoverAnim, -5.0f);
     this->colliderCyl.base.acFlags &= ~AC_ON;
-    this->colliderCyl.info.bumper.dmgFlags = DMG_DEFAULT;
-    this->colliderJntSph.elements[10].info.bumperFlags &= ~(BUMP_ON | BUMP_HOOKABLE);
-    this->colliderJntSph.elements[0].info.bumperFlags |= BUMP_ON;
+    this->colliderCyl.elem.bumper.dmgFlags = DMG_DEFAULT;
+    this->colliderJntSph.elements[10].base.bumperFlags &= ~(BUMP_ON | BUMP_HOOKABLE);
+    this->colliderJntSph.elements[0].base.bumperFlags |= BUMP_ON;
     this->vVanish = true;
     this->actor.speed = 5.0f;
     this->actionFunc = BossSst_HeadRecover;
@@ -2496,7 +2496,7 @@ void BossSst_HandSetDamage(BossSst* this, s32 damage) {
 
     this->colliderJntSph.base.atFlags |= AT_ON;
     for (i = 0; i < 11; i++) {
-        this->colliderJntSph.elements[i].info.toucher.damage = damage;
+        this->colliderJntSph.elements[i].base.toucher.damage = damage;
     }
 }
 
diff --git a/src/overlays/actors/ovl_Boss_Tw/z_boss_tw.c b/src/overlays/actors/ovl_Boss_Tw/z_boss_tw.c
index 4db3eed4a7..2dd7ca3b5d 100644
--- a/src/overlays/actors/ovl_Boss_Tw/z_boss_tw.c
+++ b/src/overlays/actors/ovl_Boss_Tw/z_boss_tw.c
@@ -464,7 +464,7 @@ void BossTw_Init(Actor* thisx, PlayState* play2) {
 
         if (this->actor.params == TW_FIRE_BLAST || this->actor.params == TW_FIRE_BLAST_GROUND) {
             this->actionFunc = BossTw_BlastFire;
-            this->collider.info.toucher.effect = 1;
+            this->collider.elem.toucher.effect = 1;
         } else if (this->actor.params == TW_ICE_BLAST || this->actor.params == TW_ICE_BLAST_GROUND) {
             this->actionFunc = BossTw_BlastIce;
         } else if (this->actor.params >= TW_DEATHBALL_KOTAKE) {
@@ -3093,19 +3093,19 @@ void BossTw_TwinrovaUpdate(Actor* thisx, PlayState* play2) {
                 BossTw_TwinrovaDamage(this, play, 0);
                 Actor_PlaySfx(&this->actor, NA_SE_EN_TWINROBA_YOUNG_DAMAGE);
             } else if (this->collider.base.acFlags & AC_HIT) {
-                ColliderInfo* info = this->collider.info.acHitInfo;
+                ColliderElement* acHitElem = this->collider.elem.acHitElem;
 
                 this->collider.base.acFlags &= ~AC_HIT;
-                if (info->toucher.dmgFlags & (DMG_SLINGSHOT | DMG_ARROW)) {}
+                if (acHitElem->toucher.dmgFlags & (DMG_SLINGSHOT | DMG_ARROW)) {}
             }
         } else if (this->collider.base.acFlags & AC_HIT) {
             u8 damage;
             u8 swordDamage;
-            ColliderInfo* info = this->collider.info.acHitInfo;
+            ColliderElement* acHitElem = this->collider.elem.acHitElem;
 
             this->collider.base.acFlags &= ~AC_HIT;
             swordDamage = false;
-            damage = CollisionCheck_GetSwordDamage(info->toucher.dmgFlags);
+            damage = CollisionCheck_GetSwordDamage(acHitElem->toucher.dmgFlags);
 
             if (damage == 0) {
                 damage = 2;
@@ -3113,7 +3113,7 @@ void BossTw_TwinrovaUpdate(Actor* thisx, PlayState* play2) {
                 swordDamage = true;
             }
 
-            if (!(info->toucher.dmgFlags & DMG_HOOKSHOT)) {
+            if (!(acHitElem->toucher.dmgFlags & DMG_HOOKSHOT)) {
                 if (((s8)this->actor.colChkInfo.health < 3) && !swordDamage) {
                     damage = 0;
                 }
@@ -4320,7 +4320,7 @@ void BossTw_BlastIce(BossTw* this, PlayState* play) {
 s32 BossTw_BlastShieldCheck(BossTw* this, PlayState* play) {
     Player* player = GET_PLAYER(play);
     s32 ret = false;
-    ColliderInfo* info;
+    ColliderElement* acHitElem;
 
     if (1) {}
 
@@ -4328,9 +4328,9 @@ s32 BossTw_BlastShieldCheck(BossTw* this, PlayState* play) {
         if (this->collider.base.acFlags & AC_HIT) {
             this->collider.base.acFlags &= ~AC_HIT;
             this->collider.base.atFlags &= ~AT_HIT;
-            info = this->collider.info.acHitInfo;
+            acHitElem = this->collider.elem.acHitElem;
 
-            if (info->toucher.dmgFlags & DMG_SHIELD) {
+            if (acHitElem->toucher.dmgFlags & DMG_SHIELD) {
                 this->work[INVINC_TIMER] = 7;
                 play->envCtx.lightBlend = 1.0f;
                 Rumble_Request(0.0f, 100, 5, 4);
diff --git a/src/overlays/actors/ovl_Boss_Va/z_boss_va.c b/src/overlays/actors/ovl_Boss_Va/z_boss_va.c
index 7a0ddfa40c..554c45e5ae 100644
--- a/src/overlays/actors/ovl_Boss_Va/z_boss_va.c
+++ b/src/overlays/actors/ovl_Boss_Va/z_boss_va.c
@@ -1129,7 +1129,7 @@ void BossVa_BodyPhase2(BossVa* this, PlayState* play) {
             Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_BLUE, 255, COLORFILTER_BUFFLAG_OPA, 160);
             this->actor.colorFilterTimer = this->invincibilityTimer;
         } else {
-            this->colliderBody.info.bumper.dmgFlags = DMG_BOOMERANG;
+            this->colliderBody.elem.bumper.dmgFlags = DMG_BOOMERANG;
         }
     }
 
@@ -1139,7 +1139,7 @@ void BossVa_BodyPhase2(BossVa* this, PlayState* play) {
         if (this->colliderBody.base.ac->id == ACTOR_EN_BOOM) {
             sPhase2Timer &= 0xFE00;
             Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_BLUE, 255, COLORFILTER_BUFFLAG_OPA, 160);
-            this->colliderBody.info.bumper.dmgFlags = DMG_SWORD | DMG_BOOMERANG | DMG_DEKU_STICK;
+            this->colliderBody.elem.bumper.dmgFlags = DMG_SWORD | DMG_BOOMERANG | DMG_DEKU_STICK;
         } else {
             sKillBari++;
             if ((this->actor.colorFilterTimer != 0) && !(this->actor.colorFilterParams & 0x4000)) {
@@ -1217,7 +1217,7 @@ void BossVa_BodyPhase2(BossVa* this, PlayState* play) {
 }
 
 void BossVa_SetupBodyPhase3(BossVa* this) {
-    this->colliderBody.info.bumper.dmgFlags = DMG_BOOMERANG;
+    this->colliderBody.elem.bumper.dmgFlags = DMG_BOOMERANG;
     this->actor.speed = 0.0f;
     sPhase3StopMoving = false;
     BossVa_SetupAction(this, BossVa_BodyPhase3);
@@ -1421,7 +1421,7 @@ void BossVa_BodyPhase4(BossVa* this, PlayState* play) {
             }
             Math_SmoothStepToF(&this->actor.speed, ((sFightPhase - PHASE_4 + 1) * 1.5f) + 4.0f, 1.0f, 0.25f, 0.0f);
         }
-        this->colliderBody.info.bumper.dmgFlags = DMG_BOOMERANG;
+        this->colliderBody.elem.bumper.dmgFlags = DMG_BOOMERANG;
     } else {
         Math_SmoothStepToS(&this->vaBodySpinRate, 0, 1, 0x96, 0);
         if (this->timer > 0) {
@@ -1429,7 +1429,7 @@ void BossVa_BodyPhase4(BossVa* this, PlayState* play) {
                 this->timer = 35;
             }
             Math_SmoothStepToF(&this->actor.shape.yOffset, -480.0f, 1.0f, 30.0f, 0.0f);
-            this->colliderBody.info.bumper.dmgFlags = DMG_SWORD | DMG_BOOMERANG | DMG_DEKU_STICK;
+            this->colliderBody.elem.bumper.dmgFlags = DMG_SWORD | DMG_BOOMERANG | DMG_DEKU_STICK;
             this->timer--;
         } else {
             if ((player->stateFlags1 & PLAYER_STATE1_26) && (this->timer < -60)) {
diff --git a/src/overlays/actors/ovl_Door_Killer/z_door_killer.c b/src/overlays/actors/ovl_Door_Killer/z_door_killer.c
index 1f4aeb2ce5..ff1e4e6572 100644
--- a/src/overlays/actors/ovl_Door_Killer/z_door_killer.c
+++ b/src/overlays/actors/ovl_Door_Killer/z_door_killer.c
@@ -228,7 +228,7 @@ void DoorKiller_FallAsRubble(DoorKiller* this, PlayState* play) {
 
 s32 DoorKiller_IsHit(Actor* thisx, PlayState* play) {
     DoorKiller* this = (DoorKiller*)thisx;
-    if ((this->colliderCylinder.base.acFlags & AC_HIT) && (this->colliderCylinder.info.acHitInfo != NULL)) {
+    if ((this->colliderCylinder.base.acFlags & AC_HIT) && (this->colliderCylinder.elem.acHitElem != NULL)) {
         return true;
     }
     return false;
@@ -423,10 +423,10 @@ void DoorKiller_Wait(DoorKiller* this, PlayState* play) {
 
     if (DoorKiller_IsHit(&this->actor, play)) {
         // AC cylinder: wobble if hit by most weapons, die if hit by explosives or hammer
-        if (this->colliderCylinder.info.acHitInfo->toucher.dmgFlags & (DMG_RANGED | DMG_SLASH | DMG_DEKU_STICK)) {
+        if (this->colliderCylinder.elem.acHitElem->toucher.dmgFlags & (DMG_RANGED | DMG_SLASH | DMG_DEKU_STICK)) {
             this->timer = 16;
             this->actionFunc = DoorKiller_Wobble;
-        } else if (this->colliderCylinder.info.acHitInfo->toucher.dmgFlags & (DMG_HAMMER_SWING | DMG_EXPLOSIVE)) {
+        } else if (this->colliderCylinder.elem.acHitElem->toucher.dmgFlags & (DMG_HAMMER_SWING | DMG_EXPLOSIVE)) {
             DoorKiller_SpawnRubble(&this->actor, play);
             this->actionFunc = DoorKiller_Die;
             SfxSource_PlaySfxAtFixedWorldPos(play, &this->actor.world.pos, 20, NA_SE_EN_KDOOR_BREAK);
diff --git a/src/overlays/actors/ovl_En_Am/z_en_am.c b/src/overlays/actors/ovl_En_Am/z_en_am.c
index 64cca6b7e2..932308eb20 100644
--- a/src/overlays/actors/ovl_En_Am/z_en_am.c
+++ b/src/overlays/actors/ovl_En_Am/z_en_am.c
@@ -798,7 +798,7 @@ void EnAm_UpdateDamage(EnAm* this, PlayState* play) {
             if (this->dyna.actor.colChkInfo.damageEffect != AM_DMGEFF_MAGIC_FIRE_LIGHT) {
                 this->unk_264 = 0;
                 this->damageEffect = this->dyna.actor.colChkInfo.damageEffect;
-                Actor_SetDropFlag(&this->dyna.actor, &this->hurtCollider.info, false);
+                Actor_SetDropFlag(&this->dyna.actor, &this->hurtCollider.elem, false);
 
                 if ((this->dyna.actor.colChkInfo.damageEffect == AM_DMGEFF_NUT) ||
                     (this->dyna.actor.colChkInfo.damageEffect == AM_DMGEFF_STUN) ||
diff --git a/src/overlays/actors/ovl_En_Anubice_Fire/z_en_anubice_fire.c b/src/overlays/actors/ovl_En_Anubice_Fire/z_en_anubice_fire.c
index af3b0dc8d3..897d216677 100644
--- a/src/overlays/actors/ovl_En_Anubice_Fire/z_en_anubice_fire.c
+++ b/src/overlays/actors/ovl_En_Anubice_Fire/z_en_anubice_fire.c
@@ -113,7 +113,7 @@ void func_809B27D8(EnAnubiceFire* this, PlayState* play) {
             Actor_PlaySfx(&this->actor, NA_SE_IT_SHIELD_REFLECT_SW);
             this->cylinder.base.atFlags &= ~(AT_HIT | AT_BOUNCED | AT_TYPE_ENEMY);
             this->cylinder.base.atFlags |= AT_TYPE_PLAYER;
-            this->cylinder.info.toucher.dmgFlags = DMG_DEKU_STICK;
+            this->cylinder.elem.toucher.dmgFlags = DMG_DEKU_STICK;
             this->unk_15A = 30;
             this->actor.params = 1;
             this->actor.velocity.x *= -1.0f;
diff --git a/src/overlays/actors/ovl_En_Arrow/z_en_arrow.c b/src/overlays/actors/ovl_En_Arrow/z_en_arrow.c
index 8c4a49ff60..84a05c3b16 100644
--- a/src/overlays/actors/ovl_En_Arrow/z_en_arrow.c
+++ b/src/overlays/actors/ovl_En_Arrow/z_en_arrow.c
@@ -121,15 +121,15 @@ void EnArrow_Init(Actor* thisx, PlayState* play) {
         Collider_SetQuad(play, &this->collider, &this->actor, &sColliderInit);
 
         if (this->actor.params <= ARROW_NORMAL) {
-            this->collider.info.toucherFlags &= ~TOUCH_SFX_MASK;
-            this->collider.info.toucherFlags |= TOUCH_SFX_NORMAL;
+            this->collider.elem.toucherFlags &= ~TOUCH_SFX_MASK;
+            this->collider.elem.toucherFlags |= TOUCH_SFX_NORMAL;
         }
 
         if (this->actor.params < 0) {
             this->collider.base.atFlags = (AT_ON | AT_TYPE_ENEMY);
         } else if (this->actor.params <= ARROW_SEED) {
-            this->collider.info.toucher.dmgFlags = dmgFlags[this->actor.params];
-            LOG_HEX("this->at_info.cl_elem.at_btl_info.at_type", this->collider.info.toucher.dmgFlags,
+            this->collider.elem.toucher.dmgFlags = dmgFlags[this->actor.params];
+            LOG_HEX("this->at_info.cl_elem.at_btl_info.at_type", this->collider.elem.toucher.dmgFlags,
                     "../z_en_arrow.c", 707);
         }
     }
@@ -284,7 +284,7 @@ void EnArrow_Fly(EnArrow* this, PlayState* play) {
         } else {
             EffectSsHitMark_SpawnCustomScale(play, 0, 150, &this->actor.world.pos);
 
-            if (atTouched && (this->collider.info.atHitInfo->elemType != ELEMTYPE_UNK4)) {
+            if (atTouched && (this->collider.elem.atHitElem->elemType != ELEMTYPE_UNK4)) {
                 hitActor = this->collider.base.at;
 
                 if ((hitActor->update != NULL) && !(this->collider.base.atFlags & AT_BOUNCED) &&
@@ -300,10 +300,10 @@ void EnArrow_Fly(EnArrow* this, PlayState* play) {
                     this->hitFlags |= 1;
                     this->hitFlags |= 2;
 
-                    if (this->collider.info.atHitInfo->bumperFlags & BUMP_HIT) {
-                        this->actor.world.pos.x = this->collider.info.atHitInfo->bumper.hitPos.x;
-                        this->actor.world.pos.y = this->collider.info.atHitInfo->bumper.hitPos.y;
-                        this->actor.world.pos.z = this->collider.info.atHitInfo->bumper.hitPos.z;
+                    if (this->collider.elem.atHitElem->bumperFlags & BUMP_HIT) {
+                        this->actor.world.pos.x = this->collider.elem.atHitElem->bumper.hitPos.x;
+                        this->actor.world.pos.y = this->collider.elem.atHitElem->bumper.hitPos.y;
+                        this->actor.world.pos.z = this->collider.elem.atHitElem->bumper.hitPos.z;
                     }
 
                     func_809B3CEC(play, this);
diff --git a/src/overlays/actors/ovl_En_Bb/z_en_bb.c b/src/overlays/actors/ovl_En_Bb/z_en_bb.c
index 865c9f3128..b6bca7f72f 100644
--- a/src/overlays/actors/ovl_En_Bb/z_en_bb.c
+++ b/src/overlays/actors/ovl_En_Bb/z_en_bb.c
@@ -330,9 +330,9 @@ void EnBb_Init(Actor* thisx, PlayState* play) {
         this->timer = 0;
         this->flameScaleY = 80.0f;
         this->flameScaleX = 100.0f;
-        this->collider.elements[0].info.toucherFlags = TOUCH_ON | TOUCH_SFX_HARD;
-        this->collider.elements[0].info.toucher.dmgFlags = DMG_DEFAULT;
-        this->collider.elements[0].info.toucher.damage = 8;
+        this->collider.elements[0].base.toucherFlags = TOUCH_ON | TOUCH_SFX_HARD;
+        this->collider.elements[0].base.toucher.dmgFlags = DMG_DEFAULT;
+        this->collider.elements[0].base.toucher.damage = 8;
         this->bobSize = this->actionState * 20.0f;
         this->flamePrimAlpha = 255;
         this->moveMode = BBMOVE_NORMAL;
@@ -350,7 +350,7 @@ void EnBb_Init(Actor* thisx, PlayState* play) {
                 thisx->naviEnemyId = NAVI_ENEMY_RED_BUBBLE;
                 thisx->colChkInfo.damageTable = &sDamageTableRed;
                 this->flameEnvColor.r = 255;
-                this->collider.elements[0].info.toucher.effect = 1;
+                this->collider.elements[0].base.toucher.effect = 1;
                 EnBb_SetupRed(play, this);
                 break;
             case ENBB_WHITE:
@@ -1151,10 +1151,10 @@ void EnBb_CollisionCheck(EnBb* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
         this->dmgEffect = this->actor.colChkInfo.damageEffect;
-        Actor_SetDropFlag(&this->actor, &this->collider.elements[0].info, false);
+        Actor_SetDropFlag(&this->actor, &this->collider.elements[0].base, false);
         switch (this->dmgEffect) {
             case 7:
-                this->actor.freezeTimer = this->collider.elements[0].info.acHitInfo->toucher.damage;
+                this->actor.freezeTimer = this->collider.elements[0].base.acHitElem->toucher.damage;
                 FALLTHROUGH;
             case 5:
                 this->fireIceTimer = 0x30;
@@ -1164,7 +1164,7 @@ void EnBb_CollisionCheck(EnBb* this, PlayState* play) {
                 //! Din's Fire on a white bubble will do just that. The mechanism is complex and described below.
                 goto block_15;
             case 6:
-                this->actor.freezeTimer = this->collider.elements[0].info.acHitInfo->toucher.damage;
+                this->actor.freezeTimer = this->collider.elements[0].base.acHitElem->toucher.damage;
                 break;
             case 8:
             case 9:
diff --git a/src/overlays/actors/ovl_En_Bigokuta/z_en_bigokuta.c b/src/overlays/actors/ovl_En_Bigokuta/z_en_bigokuta.c
index f3ac29088e..e58bd6b2a4 100644
--- a/src/overlays/actors/ovl_En_Bigokuta/z_en_bigokuta.c
+++ b/src/overlays/actors/ovl_En_Bigokuta/z_en_bigokuta.c
@@ -333,7 +333,7 @@ void func_809BD524(EnBigokuta* this) {
     this->unk_19A = 0;
     this->cylinder[0].base.atFlags |= AT_ON;
     Actor_PlaySfx(&this->actor, NA_SE_EN_DAIOCTA_MAHI);
-    if (this->collider.elements->info.acHitInfo->toucher.dmgFlags & DMG_DEKU_NUT) {
+    if (this->collider.elements[0].base.acHitElem->toucher.dmgFlags & DMG_DEKU_NUT) {
         this->unk_195 = true;
         this->unk_196 = 20;
     } else {
diff --git a/src/overlays/actors/ovl_En_Bili/z_en_bili.c b/src/overlays/actors/ovl_En_Bili/z_en_bili.c
index 16865616bf..de0a12eebf 100644
--- a/src/overlays/actors/ovl_En_Bili/z_en_bili.c
+++ b/src/overlays/actors/ovl_En_Bili/z_en_bili.c
@@ -141,7 +141,7 @@ void EnBili_Destroy(Actor* thisx, PlayState* play) {
 
 void EnBili_SetupFloatIdle(EnBili* this) {
     this->actor.speed = 0.7f;
-    this->collider.info.bumper.effect = 1; // Shock?
+    this->collider.elem.bumper.effect = 1; // Shock?
     this->timer = 32;
     this->collider.base.atFlags |= AT_ON;
     this->collider.base.acFlags |= AC_ON;
@@ -237,7 +237,7 @@ void EnBili_SetupDie(EnBili* this) {
  */
 void EnBili_SetupStunned(EnBili* this) {
     this->timer = 80;
-    this->collider.info.bumper.effect = 0;
+    this->collider.elem.bumper.effect = 0;
     this->actor.gravity = -1.0f;
     this->actor.speed = 0.0f;
     Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_BLUE, 150, COLORFILTER_BUFFLAG_XLU, 80);
@@ -549,7 +549,7 @@ void EnBili_UpdateDamage(EnBili* this, PlayState* play) {
 
     if ((this->actor.colChkInfo.health != 0) && (this->collider.base.acFlags & AC_HIT)) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
 
         if ((this->actor.colChkInfo.damageEffect != 0) || (this->actor.colChkInfo.damage != 0)) {
             if (Actor_ApplyDamage(&this->actor) == 0) {
@@ -586,7 +586,7 @@ void EnBili_UpdateDamage(EnBili* this, PlayState* play) {
                 EnBili_SetupBurnt(this);
             }
 
-            if (this->collider.info.acHitInfo->toucher.dmgFlags & DMG_ARROW) {
+            if (this->collider.elem.acHitElem->toucher.dmgFlags & DMG_ARROW) {
                 this->actor.flags |= ACTOR_FLAG_4;
             }
         }
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 27403c588a..b77839265e 100644
--- a/src/overlays/actors/ovl_En_Bom/z_en_bom.c
+++ b/src/overlays/actors/ovl_En_Bom/z_en_bom.c
@@ -101,7 +101,7 @@ void EnBom_Init(Actor* thisx, PlayState* play) {
     Collider_InitJntSph(play, &this->explosionCollider);
     Collider_SetCylinder(play, &this->bombCollider, thisx, &sCylinderInit);
     Collider_SetJntSph(play, &this->explosionCollider, thisx, &sJntSphInit, &this->explosionColliderItems[0]);
-    this->explosionColliderItems[0].info.toucher.damage += (thisx->shape.rot.z & 0xFF00) >> 8;
+    this->explosionColliderItems[0].base.toucher.damage += (thisx->shape.rot.z & 0xFF00) >> 8;
 
     thisx->shape.rot.z &= 0xFF;
     if (thisx->shape.rot.z & 0x80) {
diff --git a/src/overlays/actors/ovl_En_Brob/z_en_brob.c b/src/overlays/actors/ovl_En_Brob/z_en_brob.c
index e39a5ff212..64aa97e4d0 100644
--- a/src/overlays/actors/ovl_En_Brob/z_en_brob.c
+++ b/src/overlays/actors/ovl_En_Brob/z_en_brob.c
@@ -263,8 +263,8 @@ void EnBrob_Update(Actor* thisx, PlayState* play2) {
 
     acHits[0] = (this->colliders[0].base.acFlags & AC_HIT) != 0;
     acHits[1] = (this->colliders[1].base.acFlags & AC_HIT) != 0;
-    if ((acHits[0] && (this->colliders[0].info.acHitInfo->toucher.dmgFlags & DMG_BOOMERANG)) ||
-        (acHits[1] && (this->colliders[1].info.acHitInfo->toucher.dmgFlags & DMG_BOOMERANG))) {
+    if ((acHits[0] && (this->colliders[0].elem.acHitElem->toucher.dmgFlags & DMG_BOOMERANG)) ||
+        (acHits[1] && (this->colliders[1].elem.acHitElem->toucher.dmgFlags & DMG_BOOMERANG))) {
 
         for (i = 0; i < 2; i++) {
             this->colliders[i].base.atFlags &= ~(AT_HIT | AT_BOUNCED);
@@ -273,8 +273,8 @@ void EnBrob_Update(Actor* thisx, PlayState* play2) {
 
         EnBrob_SetupStunned(this);
     } else if ((this->colliders[0].base.atFlags & AT_HIT) || (this->colliders[1].base.atFlags & AT_HIT) ||
-               (acHits[0] && (this->colliders[0].info.acHitInfo->toucher.dmgFlags & DMG_SLASH_KOKIRI)) ||
-               (acHits[1] && (this->colliders[1].info.acHitInfo->toucher.dmgFlags & DMG_SLASH_KOKIRI))) {
+               (acHits[0] && (this->colliders[0].elem.acHitElem->toucher.dmgFlags & DMG_SLASH_KOKIRI)) ||
+               (acHits[1] && (this->colliders[1].elem.acHitElem->toucher.dmgFlags & DMG_SLASH_KOKIRI))) {
 
         if (this->actionFunc == EnBrob_MoveUp && !(this->colliders[0].base.atFlags & AT_BOUNCED) &&
             !(this->colliders[1].base.atFlags & AT_BOUNCED)) {
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 e02b9ccb3a..23f49a4625 100644
--- a/src/overlays/actors/ovl_En_Bubble/z_en_bubble.c
+++ b/src/overlays/actors/ovl_En_Bubble/z_en_bubble.c
@@ -95,12 +95,12 @@ void EnBubble_SetDimensions(EnBubble* this, f32 dim) {
 }
 
 u32 func_809CBCBC(EnBubble* this) {
-    ColliderInfo* info = &this->colliderSphere.elements[0].info;
+    ColliderElement* elem = &this->colliderSphere.elements[0].base;
 
-    info->toucher.dmgFlags = DMG_EXPLOSIVE;
-    info->toucher.effect = 0;
-    info->toucher.damage = 4;
-    info->toucherFlags = TOUCH_ON;
+    elem->toucher.dmgFlags = DMG_EXPLOSIVE;
+    elem->toucher.effect = 0;
+    elem->toucher.damage = 4;
+    elem->toucherFlags = TOUCH_ON;
     this->actor.velocity.y = 0.0f;
     return 6;
 }
@@ -112,7 +112,7 @@ u32 func_809CBCEC(EnBubble* this) {
 }
 
 void EnBubble_DamagePlayer(EnBubble* this, PlayState* play) {
-    s32 damage = -this->colliderSphere.elements[0].info.toucher.damage;
+    s32 damage = -this->colliderSphere.elements[0].base.toucher.damage;
 
     play->damagePlayer(play, damage);
     func_8002F7A0(play, &this->actor, 6.0f, this->actor.yawTowardsPlayer, 6.0f);
@@ -206,7 +206,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);
@@ -284,7 +284,7 @@ u32 func_809CC648(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->unk_1F0.x = this->colliderSphere.base.ac->velocity.x / 10.0f;
         this->unk_1F0.y = this->colliderSphere.base.ac->velocity.y / 10.0f;
         this->unk_1F0.z = this->colliderSphere.base.ac->velocity.z / 10.0f;
diff --git a/src/overlays/actors/ovl_En_Bw/z_en_bw.c b/src/overlays/actors/ovl_En_Bw/z_en_bw.c
index 1f9a76aa23..4a5b89f85c 100644
--- a/src/overlays/actors/ovl_En_Bw/z_en_bw.c
+++ b/src/overlays/actors/ovl_En_Bw/z_en_bw.c
@@ -690,7 +690,7 @@ void func_809D0584(EnBw* this, PlayState* play) {
                 return;
             }
             this->damageEffect = this->actor.colChkInfo.damageEffect;
-            Actor_SetDropFlag(&this->actor, &this->collider2.info, false);
+            Actor_SetDropFlag(&this->actor, &this->collider2.elem, false);
             if ((this->damageEffect == 1) || (this->damageEffect == 0xE)) {
                 if (this->unk_23C == 0) {
                     Actor_ApplyDamage(&this->actor);
@@ -766,7 +766,7 @@ void EnBw_Update(Actor* thisx, PlayState* play2) {
             func_8002836C(play, &thisx->world.pos, &velocity, &accel, &sp50, &sp4C, 0x3C, 0, 0x14);
         }
         if (this->unk_248 <= 0.4f) {
-            this->collider1.info.toucher.effect = 0;
+            this->collider1.elem.toucher.effect = 0;
             if (((play->gameplayFrames & 1) == 0) && (this->unk_220 < 5) && (this->unk_23C == 0)) {
                 accel.y = -0.1f;
                 velocity.x = Rand_CenteredFloat(4.0f);
@@ -786,7 +786,7 @@ void EnBw_Update(Actor* thisx, PlayState* play2) {
                               20.0f - (this->unk_248 * 40.0f));
             }
         } else {
-            this->collider1.info.toucher.effect = 1;
+            this->collider1.elem.toucher.effect = 1;
         }
 
         this->unk_234 = Actor_TestFloorInDirection(thisx, play, 50.0f, thisx->world.rot.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 4fc86e4abf..caa64d3009 100644
--- a/src/overlays/actors/ovl_En_Crow/z_en_crow.c
+++ b/src/overlays/actors/ovl_En_Crow/z_en_crow.c
@@ -411,7 +411,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[0].info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elements[0].base, true);
         if ((this->actor.colChkInfo.damageEffect != 0) || (this->actor.colChkInfo.damage != 0)) {
             if (this->actor.colChkInfo.damageEffect == 1) { // Deku Nuts
                 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 6619f809e6..73bf8d9321 100644
--- a/src/overlays/actors/ovl_En_Dekubaba/z_en_dekubaba.c
+++ b/src/overlays/actors/ovl_En_Dekubaba/z_en_dekubaba.c
@@ -278,11 +278,11 @@ void EnDekubaba_Destroy(Actor* thisx, PlayState* play) {
     Collider_DestroyJntSph(play, &this->collider);
 }
 
-void EnDekubaba_DisableHitboxes(EnDekubaba* this) {
+void EnDekubaba_DisableACColliderElems(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;
     }
 }
 
@@ -323,7 +323,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;
@@ -341,7 +341,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;
@@ -417,7 +417,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) {
@@ -441,7 +441,7 @@ void EnDekubaba_SetupSway(EnDekubaba* this) {
     this->stemSectionAngle[2] = -0x5000;
     this->stemSectionAngle[1] = -0x4800;
 
-    EnDekubaba_DisableHitboxes(this);
+    EnDekubaba_DisableACColliderElems(this);
     Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_RED, 255, COLORFILTER_BUFFLAG_OPA, 35);
     this->collider.base.acFlags &= ~AC_ON;
     this->actionFunc = EnDekubaba_Sway;
@@ -896,7 +896,7 @@ void EnDekubaba_StunnedVertical(EnDekubaba* this, PlayState* play) {
     }
 
     if (this->timer == 0) {
-        EnDekubaba_DisableHitboxes(this);
+        EnDekubaba_DisableACColliderElems(this);
 
         if (this->actor.xzDistToPlayer < 80.0f * this->size) {
             EnDekubaba_SetupPrepareLunge(this);
diff --git a/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c b/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
index 9d4d46f7c6..6fd1207fe3 100644
--- a/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
+++ b/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
@@ -204,7 +204,7 @@ void EnDekunuts_SetupGasp(EnDekunuts* this) {
 
 void EnDekunuts_SetupBeDamaged(EnDekunuts* this) {
     Animation_MorphToPlayOnce(&this->skelAnime, &gDekuNutsDamageAnim, -3.0f);
-    if (this->collider.info.acHitInfo->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
+    if (this->collider.elem.acHitElem->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
         this->actor.world.rot.y = this->collider.base.ac->world.rot.y;
     } else {
         this->actor.world.rot.y = Actor_WorldYawTowardActor(&this->actor, this->collider.base.ac) + 0x8000;
@@ -445,7 +445,7 @@ void EnDekunuts_Die(EnDekunuts* this, PlayState* play) {
 void EnDekunuts_ColliderCheck(EnDekunuts* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
         if (this->actor.colChkInfo.mass == 0x32) {
             if ((this->actor.colChkInfo.damageEffect != 0) || (this->actor.colChkInfo.damage != 0)) {
                 if (this->actor.colChkInfo.damageEffect != 1) {
diff --git a/src/overlays/actors/ovl_En_Dh/z_en_dh.c b/src/overlays/actors/ovl_En_Dh/z_en_dh.c
index ea5a0fb4a0..eb3d0b2502 100644
--- a/src/overlays/actors/ovl_En_Dh/z_en_dh.c
+++ b/src/overlays/actors/ovl_En_Dh/z_en_dh.c
@@ -304,8 +304,8 @@ void EnDh_Attack(EnDh* this, PlayState* play) {
         Animation_Change(&this->skelAnime, &object_dh_Anim_004658, -1.0f, this->skelAnime.curFrame, 0.0f, ANIMMODE_ONCE,
                          -4.0f);
         this->actionState = 4;
-        this->collider2.base.atFlags = this->collider2.elements[0].info.toucherFlags = AT_NONE; // also TOUCH_NONE
-        this->collider2.elements[0].info.toucher.dmgFlags = this->collider2.elements[0].info.toucher.damage = 0;
+        this->collider2.base.atFlags = this->collider2.elements[0].base.toucherFlags = AT_NONE; // also TOUCH_NONE
+        this->collider2.elements[0].base.toucher.dmgFlags = this->collider2.elements[0].base.toucher.damage = 0;
     }
     switch (this->actionState) {
         case 1:
@@ -318,16 +318,16 @@ void EnDh_Attack(EnDh* this, PlayState* play) {
             break;
         case 2:
             if (this->skelAnime.curFrame >= 4.0f) {
-                this->collider2.base.atFlags = this->collider2.elements[0].info.toucherFlags =
+                this->collider2.base.atFlags = this->collider2.elements[0].base.toucherFlags =
                     AT_ON | AT_TYPE_ENEMY; // also TOUCH_ON | TOUCH_SFX_WOOD
-                this->collider2.elements[0].info.toucher.dmgFlags = DMG_DEFAULT;
-                this->collider2.elements[0].info.toucher.damage = 8;
+                this->collider2.elements[0].base.toucher.dmgFlags = DMG_DEFAULT;
+                this->collider2.elements[0].base.toucher.damage = 8;
             }
             if (this->collider2.base.atFlags & AT_BOUNCED) {
                 this->collider2.base.atFlags &= ~(AT_HIT | AT_BOUNCED);
-                this->collider2.base.atFlags = this->collider2.elements[0].info.toucherFlags =
+                this->collider2.base.atFlags = this->collider2.elements[0].base.toucherFlags =
                     AT_NONE; // also TOUCH_NONE
-                this->collider2.elements[0].info.toucher.dmgFlags = this->collider2.elements[0].info.toucher.damage = 0;
+                this->collider2.elements[0].base.toucher.dmgFlags = this->collider2.elements[0].base.toucher.damage = 0;
                 this->actionState++;
             } else if (this->collider2.base.atFlags & AT_HIT) {
                 this->collider2.base.atFlags &= ~AT_HIT;
@@ -343,9 +343,9 @@ void EnDh_Attack(EnDh* this, PlayState* play) {
                 Animation_Change(&this->skelAnime, &object_dh_Anim_004658, -1.0f,
                                  Animation_GetLastFrame(&object_dh_Anim_004658), 0.0f, ANIMMODE_ONCE, -4.0f);
                 this->actionState++;
-                this->collider2.base.atFlags = this->collider2.elements[0].info.toucherFlags =
+                this->collider2.base.atFlags = this->collider2.elements[0].base.toucherFlags =
                     AT_NONE; // also TOUCH_NONE
-                this->collider2.elements[0].info.toucher.dmgFlags = this->collider2.elements[0].info.toucher.damage = 0;
+                this->collider2.elements[0].base.toucher.dmgFlags = this->collider2.elements[0].base.toucher.damage = 0;
             }
             break;
         case 5:
@@ -374,10 +374,10 @@ void EnDh_Burrow(EnDh* this, PlayState* play) {
         case 0:
             this->actionState++;
             this->drawDirtWave++;
-            this->collider1.base.atFlags = this->collider1.info.toucherFlags =
+            this->collider1.base.atFlags = this->collider1.elem.toucherFlags =
                 AT_ON | AT_TYPE_ENEMY; // also TOUCH_ON | TOUCH_SFX_WOOD
-            this->collider1.info.toucher.dmgFlags = DMG_DEFAULT;
-            this->collider1.info.toucher.damage = 4;
+            this->collider1.elem.toucher.dmgFlags = DMG_DEFAULT;
+            this->collider1.elem.toucher.damage = 4;
             FALLTHROUGH;
         case 1:
             this->dirtWavePhase += 0x47E;
@@ -393,8 +393,8 @@ void EnDh_Burrow(EnDh* this, PlayState* play) {
         case 2:
             this->drawDirtWave = false;
             this->collider1.dim.radius = 35;
-            this->collider1.base.atFlags = this->collider1.info.toucherFlags = AT_NONE; // Also TOUCH_NONE
-            this->collider1.info.toucher.dmgFlags = this->collider1.info.toucher.damage = 0;
+            this->collider1.base.atFlags = this->collider1.elem.toucherFlags = AT_NONE; // Also TOUCH_NONE
+            this->collider1.elem.toucher.dmgFlags = this->collider1.elem.toucher.damage = 0;
             EnDh_SetupWait(this);
             break;
     }
@@ -477,8 +477,8 @@ void EnDh_CollisionCheck(EnDh* this, PlayState* play) {
     if ((this->collider2.base.acFlags & AC_HIT) && !this->retreat) {
         this->collider2.base.acFlags &= ~AC_HIT;
         if ((this->actor.colChkInfo.damageEffect != 0) && (this->actor.colChkInfo.damageEffect != 6)) {
-            this->collider2.base.atFlags = this->collider2.elements[0].info.toucherFlags = AT_NONE; // also TOUCH_NONE
-            this->collider2.elements[0].info.toucher.dmgFlags = this->collider2.elements[0].info.toucher.damage = 0;
+            this->collider2.base.atFlags = this->collider2.elements[0].base.toucherFlags = AT_NONE; // also TOUCH_NONE
+            this->collider2.elements[0].base.toucher.dmgFlags = this->collider2.elements[0].base.toucher.damage = 0;
             if (player->unk_844 != 0) {
                 this->unk_258 = player->unk_845;
             }
diff --git a/src/overlays/actors/ovl_En_Dnt_Nomal/z_en_dnt_nomal.c b/src/overlays/actors/ovl_En_Dnt_Nomal/z_en_dnt_nomal.c
index 02377bcce8..0ee045349e 100644
--- a/src/overlays/actors/ovl_En_Dnt_Nomal/z_en_dnt_nomal.c
+++ b/src/overlays/actors/ovl_En_Dnt_Nomal/z_en_dnt_nomal.c
@@ -231,9 +231,9 @@ void EnDntNomal_TargetWait(EnDntNomal* this, PlayState* play) {
     if ((this->targetQuad.base.acFlags & AC_HIT) || BREG(0)) {
         this->targetQuad.base.acFlags &= ~AC_HIT;
 
-        dx = fabsf(targetX - this->targetQuad.info.bumper.hitPos.x);
-        dy = fabsf(targetY - this->targetQuad.info.bumper.hitPos.y);
-        dz = fabsf(targetZ - this->targetQuad.info.bumper.hitPos.z);
+        dx = fabsf(targetX - this->targetQuad.elem.bumper.hitPos.x);
+        dy = fabsf(targetY - this->targetQuad.elem.bumper.hitPos.y);
+        dz = fabsf(targetZ - this->targetQuad.elem.bumper.hitPos.z);
 
         scoreVel.y = 5.0f;
 
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 55b860222c..507c0da58b 100644
--- a/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
+++ b/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
@@ -605,13 +605,13 @@ void EnDodongo_SweepTail(EnDodongo* this, PlayState* play) {
 
     if (SkelAnime_Update(&this->skelAnime)) {
         if ((this->timer != 0) || (ABS(yawDiff1) < 0x4000)) {
-            this->sphElements[2].info.toucherFlags = TOUCH_NONE;
-            this->sphElements[1].info.toucherFlags = TOUCH_NONE;
+            this->sphElements[2].base.toucherFlags = TOUCH_NONE;
+            this->sphElements[1].base.toucherFlags = TOUCH_NONE;
             this->colliderBody.base.atFlags = AT_NONE;
-            this->sphElements[2].info.toucher.dmgFlags = 0;
-            this->sphElements[1].info.toucher.dmgFlags = 0;
-            this->sphElements[2].info.toucher.damage = 0;
-            this->sphElements[1].info.toucher.damage = 0;
+            this->sphElements[2].base.toucher.dmgFlags = 0;
+            this->sphElements[1].base.toucher.dmgFlags = 0;
+            this->sphElements[2].base.toucher.damage = 0;
+            this->sphElements[1].base.toucher.damage = 0;
             EnDodongo_SetupBreatheFire(this);
             this->timer = Rand_S16Offset(5, 10);
         } else {
@@ -628,10 +628,10 @@ void EnDodongo_SweepTail(EnDodongo* this, PlayState* play) {
             Actor_PlaySfx(&this->actor, NA_SE_EN_DODO_J_TAIL);
             Animation_PlayOnceSetSpeed(&this->skelAnime, animation, 2.0f);
             this->timer = 18;
-            this->colliderBody.base.atFlags = this->sphElements[1].info.toucherFlags =
-                this->sphElements[2].info.toucherFlags = AT_ON | AT_TYPE_ENEMY; // also TOUCH_ON | TOUCH_SFX_WOOD
-            this->sphElements[1].info.toucher.dmgFlags = this->sphElements[2].info.toucher.dmgFlags = DMG_DEFAULT;
-            this->sphElements[1].info.toucher.damage = this->sphElements[2].info.toucher.damage = 8;
+            this->colliderBody.base.atFlags = this->sphElements[1].base.toucherFlags =
+                this->sphElements[2].base.toucherFlags = AT_ON | AT_TYPE_ENEMY; // also TOUCH_ON | TOUCH_SFX_WOOD
+            this->sphElements[1].base.toucher.dmgFlags = this->sphElements[2].base.toucher.dmgFlags = DMG_DEFAULT;
+            this->sphElements[1].base.toucher.damage = this->sphElements[2].base.toucher.damage = 8;
         }
     } else if (this->timer > 1) {
         Vec3f tailPos;
diff --git a/src/overlays/actors/ovl_En_Eiyer/z_en_eiyer.c b/src/overlays/actors/ovl_En_Eiyer/z_en_eiyer.c
index 31d31dd6a9..6b4a7a860b 100644
--- a/src/overlays/actors/ovl_En_Eiyer/z_en_eiyer.c
+++ b/src/overlays/actors/ovl_En_Eiyer/z_en_eiyer.c
@@ -178,7 +178,7 @@ void EnEiyer_RotateAroundHome(EnEiyer* this) {
 }
 
 void EnEiyer_SetupAppearFromGround(EnEiyer* this) {
-    this->collider.info.bumper.dmgFlags = DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT;
+    this->collider.elem.bumper.dmgFlags = DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT;
     Animation_PlayLoop(&this->skelanime, &gStingerIdleAnim);
 
     this->actor.world.pos.x = this->actor.home.pos.x;
@@ -228,7 +228,7 @@ void EnEiyer_SetupInactive(EnEiyer* this) {
 void EnEiyer_SetupAmbush(EnEiyer* this, PlayState* play) {
     this->actor.speed = 0.0f;
     Animation_PlayOnce(&this->skelanime, &gStingerBackflipAnim);
-    this->collider.info.bumper.dmgFlags = DMG_DEFAULT;
+    this->collider.elem.bumper.dmgFlags = DMG_DEFAULT;
     this->basePos = this->actor.world.pos;
     this->actor.world.rot.y = this->actor.shape.rot.y;
     this->actor.flags |= ACTOR_FLAG_IGNORE_QUAKE;
@@ -290,14 +290,14 @@ void EnEiyer_SetupDie(EnEiyer* this) {
     this->timer = 20;
     Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_RED, 200, COLORFILTER_BUFFLAG_OPA, 40);
 
-    if (this->collider.info.bumper.dmgFlags != (DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT)) {
+    if (this->collider.elem.bumper.dmgFlags != (DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT)) {
         this->actor.speed = 6.0f;
         Animation_MorphToLoop(&this->skelanime, &gStingerHitAnim, -3.0f);
     } else {
         this->actor.speed -= 6.0f;
     }
 
-    this->collider.info.bumper.dmgFlags = DMG_DEFAULT;
+    this->collider.elem.bumper.dmgFlags = DMG_DEFAULT;
     this->collider.base.atFlags &= ~AT_ON;
     this->collider.base.acFlags &= ~AC_ON;
     this->actionFunc = EnEiyer_Die;
@@ -602,7 +602,7 @@ void EnEiyer_Stunned(EnEiyer* this, PlayState* play) {
 void EnEiyer_UpdateDamage(EnEiyer* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
 
         if (this->actor.colChkInfo.damageEffect != 0 || this->actor.colChkInfo.damage != 0) {
             if (Actor_ApplyDamage(&this->actor) == 0) {
@@ -612,7 +612,7 @@ void EnEiyer_UpdateDamage(EnEiyer* this, PlayState* play) {
             }
 
             // If underground, one hit kill
-            if (this->collider.info.bumper.dmgFlags == (DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT)) {
+            if (this->collider.elem.bumper.dmgFlags == (DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT)) {
                 if (this->actor.colChkInfo.damage == 0) {
                     EnEiyer_SetupAmbush(this, play);
                 } else {
@@ -687,7 +687,7 @@ s32 EnEiyer_OverrideLimbDraw(PlayState* play, s32 limbIndex, Gfx** dList, Vec3f*
         pos->z += 2500.0f;
     }
 
-    if (this->collider.info.bumper.dmgFlags == (DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT) && limbIndex != 9 &&
+    if (this->collider.elem.bumper.dmgFlags == (DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT) && limbIndex != 9 &&
         limbIndex != 10) {
         *dList = NULL;
     }
diff --git a/src/overlays/actors/ovl_En_Fd/z_en_fd.c b/src/overlays/actors/ovl_En_Fd/z_en_fd.c
index 3b000f9bfc..2b7f6bedde 100644
--- a/src/overlays/actors/ovl_En_Fd/z_en_fd.c
+++ b/src/overlays/actors/ovl_En_Fd/z_en_fd.c
@@ -275,15 +275,15 @@ s32 EnFd_CheckHammer(EnFd* this, PlayState* play) {
 
 s32 EnFd_ColliderCheck(EnFd* this, PlayState* play) {
     Player* player = GET_PLAYER(play);
-    ColliderInfo* info;
+    ColliderElement* elem;
 
     if (this->collider.base.acFlags & AC_HIT || EnFd_CheckHammer(this, play)) {
         this->collider.base.acFlags &= ~AC_HIT;
         if (this->invincibilityTimer != 0) {
             return false;
         }
-        info = &this->collider.elements[0].info;
-        if (info->acHitInfo != NULL && (info->acHitInfo->toucher.dmgFlags & DMG_HOOKSHOT)) {
+        elem = &this->collider.elements[0].base;
+        if (elem->acHitElem != NULL && (elem->acHitElem->toucher.dmgFlags & DMG_HOOKSHOT)) {
             return false;
         }
 
diff --git a/src/overlays/actors/ovl_En_Fhg_Fire/z_en_fhg_fire.c b/src/overlays/actors/ovl_En_Fhg_Fire/z_en_fhg_fire.c
index 376be6337e..1d6c8e37a8 100644
--- a/src/overlays/actors/ovl_En_Fhg_Fire/z_en_fhg_fire.c
+++ b/src/overlays/actors/ovl_En_Fhg_Fire/z_en_fhg_fire.c
@@ -476,7 +476,7 @@ void EnFhgFire_EnergyBall(EnFhgFire* this, PlayState* play) {
                         ? true
                         : false;
                 if ((this->collider.base.acFlags & AC_HIT) || canBottleReflect1) {
-                    ColliderInfo* hurtbox = this->collider.info.acHitInfo;
+                    ColliderElement* acHitElem = this->collider.elem.acHitElem;
                     s16 i2;
                     Vec3f spA8;
                     Vec3f sp9C = { 0.0f, -0.5f, 0.0f };
@@ -491,7 +491,7 @@ void EnFhgFire_EnergyBall(EnFhgFire* this, PlayState* play) {
                                                         (s16)(Rand_ZeroOne() * 25.0f) + 50, FHGFLASH_LIGHTBALL_GREEN);
                     }
                     canBottleReflect2 = canBottleReflect1;
-                    if (!canBottleReflect2 && (hurtbox->toucher.dmgFlags & DMG_SHIELD)) {
+                    if (!canBottleReflect2 && (acHitElem->toucher.dmgFlags & DMG_SHIELD)) {
                         killMode = BALL_IMPACT;
                         Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_REFLECT_MG, &player->actor.projectedPos, 4,
                                              &gSfxDefaultFreqAndVolScale, &gSfxDefaultFreqAndVolScale,
diff --git a/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c b/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
index 76f880f190..341d98dfbf 100644
--- a/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
+++ b/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
@@ -118,7 +118,7 @@ static InitChainEntry sInitChain[] = {
 
 void EnFirefly_Extinguish(EnFirefly* this) {
     this->actor.params += 2;
-    this->collider.elements[0].info.toucher.effect = 0; // None
+    this->collider.elements[0].base.toucher.effect = 0; // None
     this->auraType = KEESE_AURA_NONE;
     this->onFire = false;
     this->actor.naviEnemyId = NAVI_ENEMY_KEESE;
@@ -130,7 +130,7 @@ void EnFirefly_Ignite(EnFirefly* this) {
     } else {
         this->actor.params -= 2;
     }
-    this->collider.elements[0].info.toucher.effect = 1; // Fire
+    this->collider.elements[0].base.toucher.effect = 1; // Fire
     this->auraType = KEESE_AURA_FIRE;
     this->onFire = true;
     this->actor.naviEnemyId = NAVI_ENEMY_FIRE_KEESE;
@@ -174,10 +174,10 @@ void EnFirefly_Init(Actor* thisx, PlayState* play) {
         }
 
         if (this->actor.params == KEESE_ICE_FLY) {
-            this->collider.elements[0].info.toucher.effect = 2; // Ice
+            this->collider.elements[0].base.toucher.effect = 2; // Ice
             this->actor.naviEnemyId = NAVI_ENEMY_ICE_KEESE;
         } else {
-            this->collider.elements[0].info.toucher.effect = 0; // Nothing
+            this->collider.elements[0].base.toucher.effect = 0; // Nothing
             this->actor.naviEnemyId = NAVI_ENEMY_KEESE;
         }
 
@@ -620,7 +620,7 @@ void EnFirefly_UpdateDamage(EnFirefly* this, PlayState* play) {
 
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.elements[0].info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elements[0].base, true);
 
         if ((this->actor.colChkInfo.damageEffect != 0) || (this->actor.colChkInfo.damage != 0)) {
             if (Actor_ApplyDamage(&this->actor) == 0) {
diff --git a/src/overlays/actors/ovl_En_Floormas/z_en_floormas.c b/src/overlays/actors/ovl_En_Floormas/z_en_floormas.c
index 5ebb68cd55..1c358be368 100644
--- a/src/overlays/actors/ovl_En_Floormas/z_en_floormas.c
+++ b/src/overlays/actors/ovl_En_Floormas/z_en_floormas.c
@@ -292,7 +292,7 @@ void EnFloormas_SetupSplit(EnFloormas* this) {
                      ANIMMODE_ONCE, 0.0f);
     this->collider.dim.radius = sCylinderInit.dim.radius * 0.6f;
     this->collider.dim.height = sCylinderInit.dim.height * 0.6f;
-    this->collider.info.bumperFlags &= ~BUMP_HOOKABLE;
+    this->collider.elem.bumperFlags &= ~BUMP_HOOKABLE;
     this->actor.speed = 4.0f;
     this->actor.velocity.y = 7.0f;
     // using div creates a signed check.
@@ -389,7 +389,7 @@ void EnFloormas_SetupSmallWait(EnFloormas* this) {
 
 void EnFloormas_SetupTakeDamage(EnFloormas* this) {
     Animation_MorphToPlayOnce(&this->skelAnime, &gWallmasterDamageAnim, -3.0f);
-    if (this->collider.info.acHitInfo->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
+    if (this->collider.elem.acHitElem->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
         this->actor.world.rot.y = this->collider.base.ac->world.rot.y;
     } else {
         this->actor.world.rot.y = Actor_WorldYawTowardActor(&this->actor, this->collider.base.ac) + 0x8000;
@@ -914,7 +914,7 @@ void EnFloormas_Merge(EnFloormas* this, PlayState* play) {
             this->actor.flags &= ~ACTOR_FLAG_4;
             EnFloormas_MakeVulnerable(this);
             this->actor.params = 0;
-            this->collider.info.bumperFlags |= BUMP_HOOKABLE;
+            this->collider.elem.bumperFlags |= BUMP_HOOKABLE;
             this->actor.colChkInfo.health = sColChkInfoInit.health;
             EnFloormas_SetupStand(this);
         } else {
@@ -978,14 +978,14 @@ void EnFloormas_ColliderCheck(EnFloormas* this, PlayState* play) {
 
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
         if ((this->actor.colChkInfo.damageEffect != 0) || (this->actor.colChkInfo.damage != 0)) {
             if (this->collider.base.colType != COLTYPE_HARD) {
                 isSmall = false;
                 if (this->actor.scale.x < 0.01f) {
                     isSmall = true;
                 }
-                if (isSmall && this->collider.info.acHitInfo->toucher.dmgFlags & DMG_HOOKSHOT) {
+                if (isSmall && this->collider.elem.acHitElem->toucher.dmgFlags & DMG_HOOKSHOT) {
                     this->actor.colChkInfo.damage = 2;
                     this->actor.colChkInfo.damageEffect = 0;
                 }
diff --git a/src/overlays/actors/ovl_En_Fw/z_en_fw.c b/src/overlays/actors/ovl_En_Fw/z_en_fw.c
index 733da0a4aa..57b04ae52c 100644
--- a/src/overlays/actors/ovl_En_Fw/z_en_fw.c
+++ b/src/overlays/actors/ovl_En_Fw/z_en_fw.c
@@ -135,11 +135,11 @@ Vec3f* EnFw_GetPosAdjAroundCircle(Vec3f* dst, EnFw* this, f32 radius, s16 dir) {
 }
 
 s32 EnFw_CheckCollider(EnFw* this, PlayState* play) {
-    ColliderInfo* info;
+    ColliderElement* elem;
 
     if (this->collider.base.acFlags & AC_HIT) {
-        info = &this->collider.elements[0].info;
-        if (info->acHitInfo->toucher.dmgFlags & DMG_HOOKSHOT) {
+        elem = &this->collider.elements[0].base;
+        if (elem->acHitElem->toucher.dmgFlags & DMG_HOOKSHOT) {
             this->lastDmgHook = true;
         } else {
             this->lastDmgHook = false;
diff --git a/src/overlays/actors/ovl_En_G_Switch/z_en_g_switch.c b/src/overlays/actors/ovl_En_G_Switch/z_en_g_switch.c
index ac9610488c..b190c5a5b5 100644
--- a/src/overlays/actors/ovl_En_G_Switch/z_en_g_switch.c
+++ b/src/overlays/actors/ovl_En_G_Switch/z_en_g_switch.c
@@ -135,7 +135,7 @@ void EnGSwitch_Init(Actor* thisx, PlayState* play) {
             this->actor.scale.x = 0.25f;
             this->actor.scale.y = 0.45f;
             this->actor.scale.z = 0.25f;
-            this->collider.info.bumper.dmgFlags = DMG_ARROW;
+            this->collider.elem.bumper.dmgFlags = DMG_ARROW;
             this->objectId = OBJECT_TSUBO;
             this->requiredObjectSlot = Object_GetSlot(&play->objectCtx, this->objectId);
             if (this->requiredObjectSlot < 0) {
@@ -181,9 +181,9 @@ void EnGSwitch_Break(EnGSwitch* this, PlayState* play) {
     randPos.x = this->actor.world.pos.x + Rand_CenteredFloat(40.0f);
     randPos.y = this->actor.world.pos.y + 30.0f + Rand_CenteredFloat(35.0f);
     randPos.z = this->actor.world.pos.z + Rand_CenteredFloat(40.0f);
-    hitPos.x = this->collider.info.bumper.hitPos.x;
-    hitPos.y = this->collider.info.bumper.hitPos.y;
-    hitPos.z = this->collider.info.bumper.hitPos.z;
+    hitPos.x = this->collider.elem.bumper.hitPos.x;
+    hitPos.y = this->collider.elem.bumper.hitPos.y;
+    hitPos.z = this->collider.elem.bumper.hitPos.z;
     EffectSsHitMark_SpawnCustomScale(play, EFFECT_HITMARK_WHITE, 700, &hitPos);
     if (this->type == ENGSWITCH_ARCHERY_POT) {
         velocity.y = 15.0f;
diff --git a/src/overlays/actors/ovl_En_Ge2/z_en_ge2.c b/src/overlays/actors/ovl_En_Ge2/z_en_ge2.c
index 91410c1a21..4430ef3f7d 100644
--- a/src/overlays/actors/ovl_En_Ge2/z_en_ge2.c
+++ b/src/overlays/actors/ovl_En_Ge2/z_en_ge2.c
@@ -554,8 +554,8 @@ void EnGe2_Update(Actor* thisx, PlayState* play) {
     if ((this->stateFlags & GE2_STATE_KO) || (this->stateFlags & GE2_STATE_CAPTURING)) {
         this->actionFunc(this, play);
     } else if (this->collider.base.acFlags & AC_HIT) {
-        if ((this->collider.info.acHitInfo != NULL) &&
-            (this->collider.info.acHitInfo->toucher.dmgFlags & DMG_HOOKSHOT)) {
+        if ((this->collider.elem.acHitElem != NULL) &&
+            (this->collider.elem.acHitElem->toucher.dmgFlags & DMG_HOOKSHOT)) {
             //! @bug duration parameter is larger than 255 which messes with the internal bitpacking of the colorfilter.
             //! Because of the duration being tracked as an unsigned byte it ends up being truncated to 144
             Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_BLUE, 120, COLORFILTER_BUFFLAG_OPA, 400);
@@ -606,8 +606,8 @@ void EnGe2_UpdateStunned(Actor* thisx, PlayState* play2) {
     CollisionCheck_SetOC(play, &play->colChkCtx, &this->collider.base);
     Actor_UpdateBgCheckInfo(play, &this->actor, 40.0f, 25.0f, 40.0f, UPDBGCHECKINFO_FLAG_0 | UPDBGCHECKINFO_FLAG_2);
 
-    if ((this->collider.base.acFlags & AC_HIT) && ((this->collider.info.acHitInfo == NULL) ||
-                                                   !(this->collider.info.acHitInfo->toucher.dmgFlags & DMG_HOOKSHOT))) {
+    if ((this->collider.base.acFlags & AC_HIT) && ((this->collider.elem.acHitElem == NULL) ||
+                                                   !(this->collider.elem.acHitElem->toucher.dmgFlags & DMG_HOOKSHOT))) {
         this->actor.colorFilterTimer = 0;
         EnGe2_ChangeAction(this, GE2_ACTION_KNOCKEDOUT);
         this->timer = 100;
diff --git a/src/overlays/actors/ovl_En_GeldB/z_en_geldb.c b/src/overlays/actors/ovl_En_GeldB/z_en_geldb.c
index 0ed65e828d..ea9772ca03 100644
--- a/src/overlays/actors/ovl_En_GeldB/z_en_geldb.c
+++ b/src/overlays/actors/ovl_En_GeldB/z_en_geldb.c
@@ -1368,7 +1368,7 @@ void EnGeldB_CollisionCheck(EnGeldB* this, PlayState* play) {
         this->bodyCollider.base.acFlags &= ~AC_HIT;
         if (this->actor.colChkInfo.damageEffect != GELDB_DMG_UNK_6) {
             this->damageEffect = this->actor.colChkInfo.damageEffect;
-            Actor_SetDropFlag(&this->actor, &this->bodyCollider.info, true);
+            Actor_SetDropFlag(&this->actor, &this->bodyCollider.elem, true);
             Audio_StopSfxByPosAndId(&this->actor.projectedPos, NA_SE_EN_GERUDOFT_BREATH);
             if ((this->actor.colChkInfo.damageEffect == GELDB_DMG_STUN) ||
                 (this->actor.colChkInfo.damageEffect == GELDB_DMG_FREEZE)) {
diff --git a/src/overlays/actors/ovl_En_Go2/z_en_go2.c b/src/overlays/actors/ovl_En_Go2/z_en_go2.c
index 118dffef4d..278c4679dd 100644
--- a/src/overlays/actors/ovl_En_Go2/z_en_go2.c
+++ b/src/overlays/actors/ovl_En_Go2/z_en_go2.c
@@ -1344,7 +1344,7 @@ void EnGo2_GetItemAnimation(EnGo2* this, PlayState* play) {
 
 void EnGo2_SetupRolling(EnGo2* this, PlayState* play) {
     if ((this->actor.params & 0x1F) == GORON_CITY_ROLLING_BIG || (this->actor.params & 0x1F) == GORON_CITY_LINK) {
-        this->collider.info.bumperFlags = BUMP_ON;
+        this->collider.elem.bumperFlags = BUMP_ON;
         this->actor.speed = GET_INFTABLE(INFTABLE_11E) ? 6.0f : 3.6000001f;
     } else {
         this->actor.speed = 6.0f;
@@ -1368,7 +1368,7 @@ void EnGo2_StopRolling(EnGo2* this, PlayState* play) {
             }
         }
     } else {
-        this->collider.info.bumperFlags = BUMP_NONE;
+        this->collider.elem.bumperFlags = BUMP_NONE;
     }
 
     this->actor.shape.rot = this->actor.world.rot;
diff --git a/src/overlays/actors/ovl_En_Goma/z_en_goma.c b/src/overlays/actors/ovl_En_Goma/z_en_goma.c
index 167c5d24f2..a281827ae4 100644
--- a/src/overlays/actors/ovl_En_Goma/z_en_goma.c
+++ b/src/overlays/actors/ovl_En_Goma/z_en_goma.c
@@ -610,7 +610,7 @@ void EnGoma_UpdateHit(EnGoma* this, PlayState* play) {
     if (this->hurtTimer != 0) {
         this->hurtTimer--;
     } else {
-        ColliderInfo* acHitInfo;
+        ColliderElement* acHitElem;
         u8 swordDamage;
 
         if ((this->colCyl1.base.atFlags & AT_HIT) && this->actionFunc == EnGoma_Jump) {
@@ -620,11 +620,11 @@ void EnGoma_UpdateHit(EnGoma* this, PlayState* play) {
         }
 
         if ((this->colCyl2.base.acFlags & AC_HIT) && (s8)this->actor.colChkInfo.health > 0) {
-            acHitInfo = this->colCyl2.info.acHitInfo;
+            acHitElem = this->colCyl2.elem.acHitElem;
             this->colCyl2.base.acFlags &= ~AC_HIT;
 
             if (this->gomaType == ENGOMA_NORMAL) {
-                u32 dmgFlags = acHitInfo->toucher.dmgFlags;
+                u32 dmgFlags = acHitElem->toucher.dmgFlags;
 
                 if (dmgFlags & DMG_SHIELD) {
                     if (this->actionFunc == EnGoma_Jump) {
diff --git a/src/overlays/actors/ovl_En_Hintnuts/z_en_hintnuts.c b/src/overlays/actors/ovl_En_Hintnuts/z_en_hintnuts.c
index a65a8e7312..c9007ebd9b 100644
--- a/src/overlays/actors/ovl_En_Hintnuts/z_en_hintnuts.c
+++ b/src/overlays/actors/ovl_En_Hintnuts/z_en_hintnuts.c
@@ -461,7 +461,7 @@ void EnHintnuts_Freeze(EnHintnuts* this, PlayState* play) {
 void EnHintnuts_ColliderCheck(EnHintnuts* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
         if (this->collider.base.ac->id != ACTOR_EN_NUTSBALL) {
             EnHintnuts_SetupBurrow(this);
         } else {
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 d205fb9eb4..351b29267a 100644
--- a/src/overlays/actors/ovl_En_Horse/z_en_horse.c
+++ b/src/overlays/actors/ovl_En_Horse/z_en_horse.c
@@ -560,7 +560,7 @@ void EnHorse_UpdateIngoRaceInfo(EnHorse* this, PlayState* play, RaceInfo* raceIn
 
     if (distSq < SQ(300.0f)) {
         playerDist = this->actor.xzDistToPlayer;
-        if (playerDist < 130.0f || this->jntSph.elements[0].info.ocElemFlags & OCELEM_HIT) {
+        if (playerDist < 130.0f || this->jntSph.elements[0].base.ocElemFlags & OCELEM_HIT) {
             if (Math_SinS(this->actor.yawTowardsPlayer - this->actor.world.rot.y) > 0.0f) {
                 this->actor.world.rot.y -= 280;
             } else {
@@ -3533,7 +3533,7 @@ void EnHorse_Update(Actor* thisx, PlayState* play2) {
                 this->rider->shape.rot.y = thisx->shape.rot.y;
             }
         }
-        if (this->jntSph.elements[0].info.ocElemFlags & OCELEM_HIT) {
+        if (this->jntSph.elements[0].base.ocElemFlags & OCELEM_HIT) {
             if (thisx->speed > 6.0f) {
                 thisx->speed -= 1.0f;
             }
diff --git a/src/overlays/actors/ovl_En_Ik/z_en_ik.c b/src/overlays/actors/ovl_En_Ik/z_en_ik.c
index 35f5deb878..9727a18135 100644
--- a/src/overlays/actors/ovl_En_Ik/z_en_ik.c
+++ b/src/overlays/actors/ovl_En_Ik/z_en_ik.c
@@ -731,7 +731,7 @@ void EnIk_UpdateDamage(EnIk* this, PlayState* play) {
         sparksPos = this->actor.world.pos;
         sparksPos.y += 50.0f;
 
-        Actor_SetDropFlag(&this->actor, &this->bodyCollider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->bodyCollider.elem, true);
 
         this->damageEffect = this->actor.colChkInfo.damageEffect;
         this->bodyCollider.base.acFlags &= ~AC_HIT;
diff --git a/src/overlays/actors/ovl_En_Ishi/z_en_ishi.c b/src/overlays/actors/ovl_En_Ishi/z_en_ishi.c
index 63c41a7764..c70a3f7579 100644
--- a/src/overlays/actors/ovl_En_Ishi/z_en_ishi.c
+++ b/src/overlays/actors/ovl_En_Ishi/z_en_ishi.c
@@ -356,7 +356,7 @@ void EnIshi_Wait(EnIshi* this, PlayState* play) {
             EnIshi_SpawnBugs(this, play);
         }
     } else if ((this->collider.base.acFlags & AC_HIT) && (type == ROCK_SMALL) &&
-               this->collider.info.acHitInfo->toucher.dmgFlags & (DMG_HAMMER | DMG_EXPLOSIVE)) {
+               this->collider.elem.acHitElem->toucher.dmgFlags & (DMG_HAMMER | DMG_EXPLOSIVE)) {
         EnIshi_DropCollectible(this, play);
         SfxSource_PlaySfxAtFixedWorldPos(play, &this->actor.world.pos, sBreakSfxDurations[type], sBreakSfxIds[type]);
         sFragmentSpawnFuncs[type](this, play);
diff --git a/src/overlays/actors/ovl_En_Kanban/z_en_kanban.c b/src/overlays/actors/ovl_En_Kanban/z_en_kanban.c
index f4b3e6f60a..2db5dbfcf8 100644
--- a/src/overlays/actors/ovl_En_Kanban/z_en_kanban.c
+++ b/src/overlays/actors/ovl_En_Kanban/z_en_kanban.c
@@ -295,11 +295,11 @@ void EnKanban_Update(Actor* thisx, PlayState* play2) {
                                                       this->actor.world.pos.z, this->actor.shape.rot.x,
                                                       this->actor.shape.rot.y, this->actor.shape.rot.z, ENKANBAN_PIECE);
                 if (piece != NULL) {
-                    ColliderInfo* hitItem = this->collider.info.acHitInfo;
+                    ColliderElement* acHitElem = this->collider.elem.acHitElem;
                     s16 yawDiff = this->actor.yawTowardsPlayer - this->actor.shape.rot.y;
                     u8 i;
 
-                    if (hitItem->toucher.dmgFlags & DMG_SLASH) {
+                    if (acHitElem->toucher.dmgFlags & DMG_SLASH) {
                         this->cutType = sCutTypes[player->meleeWeaponAnimation];
                     } else {
                         this->cutType = CUT_POST;
diff --git a/src/overlays/actors/ovl_En_Karebaba/z_en_karebaba.c b/src/overlays/actors/ovl_En_Karebaba/z_en_karebaba.c
index b967a5ee84..523b041522 100644
--- a/src/overlays/actors/ovl_En_Karebaba/z_en_karebaba.c
+++ b/src/overlays/actors/ovl_En_Karebaba/z_en_karebaba.c
@@ -125,7 +125,7 @@ void EnKarebaba_ResetCollider(EnKarebaba* this) {
     this->bodyCollider.dim.height = 25;
     this->bodyCollider.base.colType = COLTYPE_HARD;
     this->bodyCollider.base.acFlags |= AC_HARD;
-    this->bodyCollider.info.bumper.dmgFlags = DMG_DEFAULT;
+    this->bodyCollider.elem.bumper.dmgFlags = DMG_DEFAULT;
     this->headCollider.dim.height = 25;
 }
 
@@ -155,7 +155,7 @@ void EnKarebaba_SetupUpright(EnKarebaba* this) {
         Actor_SetScale(&this->actor, 0.01f);
         this->bodyCollider.base.colType = COLTYPE_HIT6;
         this->bodyCollider.base.acFlags &= ~AC_HARD;
-        this->bodyCollider.info.bumper.dmgFlags =
+        this->bodyCollider.elem.bumper.dmgFlags =
             !LINK_IS_ADULT ? ((DMG_SWORD | DMG_BOOMERANG) & ~DMG_JUMP_MASTER) : (DMG_SWORD | DMG_BOOMERANG);
         this->bodyCollider.dim.radius = 15;
         this->bodyCollider.dim.height = 80;
diff --git a/src/overlays/actors/ovl_En_M_Thunder/z_en_m_thunder.c b/src/overlays/actors/ovl_En_M_Thunder/z_en_m_thunder.c
index 3877f1ddb3..4b20f4018c 100644
--- a/src/overlays/actors/ovl_En_M_Thunder/z_en_m_thunder.c
+++ b/src/overlays/actors/ovl_En_M_Thunder/z_en_m_thunder.c
@@ -97,7 +97,7 @@ void EnMThunder_Init(Actor* thisx, PlayState* play2) {
 
         player->stateFlags2 &= ~PLAYER_STATE2_17;
         this->unk_1CA = 1;
-        this->collider.info.toucher.dmgFlags = D_80AA044C[this->unk_1C7];
+        this->collider.elem.toucher.dmgFlags = D_80AA044C[this->unk_1C7];
         this->unk_1C6 = 1;
         this->unk_1C9 = ((this->unk_1C7 == 1) ? 2 : 4);
         func_80A9EFE0(this, func_80A9F9B4);
@@ -196,11 +196,11 @@ void func_80A9F408(EnMThunder* this, PlayState* play) {
                 gSaveContext.magicState = MAGIC_STATE_CONSUME_SETUP;
             }
             if (player->unk_858 < 0.85f) {
-                this->collider.info.toucher.dmgFlags = D_80AA044C[this->unk_1C7];
+                this->collider.elem.toucher.dmgFlags = D_80AA044C[this->unk_1C7];
                 this->unk_1C6 = 1;
                 this->unk_1C9 = ((this->unk_1C7 == 1) ? 2 : 4);
             } else {
-                this->collider.info.toucher.dmgFlags = D_80AA0458[this->unk_1C7];
+                this->collider.elem.toucher.dmgFlags = D_80AA0458[this->unk_1C7];
                 this->unk_1C6 = 0;
                 this->unk_1C9 = ((this->unk_1C7 == 1) ? 4 : 8);
             }
diff --git a/src/overlays/actors/ovl_En_Mb/z_en_mb.c b/src/overlays/actors/ovl_En_Mb/z_en_mb.c
index 498aea3afe..44f1e64336 100644
--- a/src/overlays/actors/ovl_En_Mb/z_en_mb.c
+++ b/src/overlays/actors/ovl_En_Mb/z_en_mb.c
@@ -89,7 +89,7 @@ void EnMb_SpearPatrolImmediateCharge(EnMb* this, PlayState* play);
 void EnMb_ClubWaitAfterAttack(EnMb* this, PlayState* play);
 void EnMb_ClubDamaged(EnMb* this, PlayState* play);
 
-static ColliderCylinderInit sHitboxInit = {
+static ColliderCylinderInit sBodyColliderInit = {
     {
         COLTYPE_HIT0,
         AT_NONE,
@@ -265,8 +265,8 @@ void EnMb_Init(Actor* thisx, PlayState* play) {
     ActorShape_Init(&this->actor.shape, 0.0f, ActorShadow_DrawCircle, 46.0f);
     this->actor.colChkInfo.mass = MASS_IMMOVABLE;
     this->actor.colChkInfo.damageTable = &sSpearMoblinDamageTable;
-    Collider_InitCylinder(play, &this->hitbox);
-    Collider_SetCylinder(play, &this->hitbox, &this->actor, &sHitboxInit);
+    Collider_InitCylinder(play, &this->bodyCollider);
+    Collider_SetCylinder(play, &this->bodyCollider, &this->actor, &sBodyColliderInit);
     Collider_InitTris(play, &this->frontShielding);
     Collider_SetTris(play, &this->frontShielding, &this->actor, &sFrontShieldingInit, this->frontShieldingTris);
     Collider_InitQuad(play, &this->attackCollider);
@@ -290,13 +290,13 @@ void EnMb_Init(Actor* thisx, PlayState* play) {
             this->actor.colChkInfo.mass = MASS_IMMOVABLE;
             this->actor.colChkInfo.damageTable = &sClubMoblinDamageTable;
             Actor_SetScale(&this->actor, 0.02f);
-            this->hitbox.dim.height = 170;
-            this->hitbox.dim.radius = 45;
+            this->bodyCollider.dim.height = 170;
+            this->bodyCollider.dim.radius = 45;
             this->actor.uncullZoneForward = 4000.0f;
             this->actor.uncullZoneScale = 800.0f;
             this->actor.uncullZoneDownward = 1800.0f;
             this->playerDetectionRange = 710.0f;
-            this->attackCollider.info.toucher.dmgFlags = DMG_UNBLOCKABLE;
+            this->attackCollider.elem.toucher.dmgFlags = DMG_UNBLOCKABLE;
 
             relYawFromPlayer =
                 this->actor.world.rot.y - Math_Vec3f_Yaw(&this->actor.world.pos, &player->actor.world.pos);
@@ -333,7 +333,7 @@ void EnMb_Destroy(Actor* thisx, PlayState* play) {
     EnMb* this = (EnMb*)thisx;
 
     Collider_DestroyTris(play, &this->frontShielding);
-    Collider_DestroyCylinder(play, &this->hitbox);
+    Collider_DestroyCylinder(play, &this->bodyCollider);
     Collider_DestroyQuad(play, &this->attackCollider);
 }
 
@@ -575,8 +575,8 @@ void EnMb_SetupClubDead(EnMb* this) {
     Animation_MorphToPlayOnce(&this->skelAnime, &gEnMbClubFallOnItsBackAnim, -4.0f);
     this->state = ENMB_STATE_CLUB_DEAD;
     this->actor.flags &= ~ACTOR_FLAG_0;
-    this->hitbox.dim.height = 80;
-    this->hitbox.dim.radius = 95;
+    this->bodyCollider.dim.height = 80;
+    this->bodyCollider.dim.radius = 95;
     this->timer1 = 30;
     this->actor.speed = 0.0f;
     Actor_PlaySfx(&this->actor, NA_SE_EN_MORIBLIN_DEAD);
@@ -1373,9 +1373,9 @@ void EnMb_CheckColliding(EnMb* this, PlayState* play) {
 
     if (this->frontShielding.base.acFlags & AC_HIT) {
         this->frontShielding.base.acFlags &= ~(AC_HIT | AC_BOUNCED);
-        this->hitbox.base.acFlags &= ~AC_HIT;
-    } else if ((this->hitbox.base.acFlags & AC_HIT) && this->state >= ENMB_STATE_STUNNED) {
-        this->hitbox.base.acFlags &= ~AC_HIT;
+        this->bodyCollider.base.acFlags &= ~AC_HIT;
+    } else if ((this->bodyCollider.base.acFlags & AC_HIT) && this->state >= ENMB_STATE_STUNNED) {
+        this->bodyCollider.base.acFlags &= ~AC_HIT;
         if (this->actor.colChkInfo.damageEffect != ENMB_DMGEFF_IGNORE &&
             this->actor.colChkInfo.damageEffect != ENMB_DMGEFF_FREEZE) {
             if ((player->stateFlags2 & PLAYER_STATE2_7) && player->actor.parent == &this->actor) {
@@ -1386,7 +1386,7 @@ void EnMb_CheckColliding(EnMb* this, PlayState* play) {
             }
             this->damageEffect = this->actor.colChkInfo.damageEffect;
             this->attack = ENMB_ATTACK_NONE;
-            Actor_SetDropFlag(&this->actor, &this->hitbox.info, false);
+            Actor_SetDropFlag(&this->actor, &this->bodyCollider.elem, false);
             if (this->actor.colChkInfo.damageEffect == ENMB_DMGEFF_STUN ||
                 this->actor.colChkInfo.damageEffect == ENMB_DMGEFF_STUN_ICE) {
                 if (this->state != ENMB_STATE_STUNNED) {
@@ -1426,15 +1426,15 @@ void EnMb_Update(Actor* thisx, PlayState* play) {
                                 UPDBGCHECKINFO_FLAG_0 | UPDBGCHECKINFO_FLAG_2 | UPDBGCHECKINFO_FLAG_3 |
                                     UPDBGCHECKINFO_FLAG_4);
         Actor_SetFocus(thisx, thisx->scale.x * 4500.0f);
-        Collider_UpdateCylinder(thisx, &this->hitbox);
+        Collider_UpdateCylinder(thisx, &this->bodyCollider);
         if (thisx->colChkInfo.health <= 0) {
-            this->hitbox.dim.pos.x += Math_SinS(thisx->shape.rot.y) * (-4400.0f * thisx->scale.y);
-            this->hitbox.dim.pos.z += Math_CosS(thisx->shape.rot.y) * (-4400.0f * thisx->scale.y);
+            this->bodyCollider.dim.pos.x += Math_SinS(thisx->shape.rot.y) * (-4400.0f * thisx->scale.y);
+            this->bodyCollider.dim.pos.z += Math_CosS(thisx->shape.rot.y) * (-4400.0f * thisx->scale.y);
         }
-        CollisionCheck_SetOC(play, &play->colChkCtx, &this->hitbox.base);
+        CollisionCheck_SetOC(play, &play->colChkCtx, &this->bodyCollider.base);
         if (this->state >= ENMB_STATE_STUNNED &&
             (thisx->params == ENMB_TYPE_CLUB || this->state != ENMB_STATE_ATTACK)) {
-            CollisionCheck_SetAC(play, &play->colChkCtx, &this->hitbox.base);
+            CollisionCheck_SetAC(play, &play->colChkCtx, &this->bodyCollider.base);
         }
         if (this->state >= ENMB_STATE_IDLE) {
             CollisionCheck_SetAC(play, &play->colChkCtx, &this->frontShielding.base);
diff --git a/src/overlays/actors/ovl_En_Mb/z_en_mb.h b/src/overlays/actors/ovl_En_Mb/z_en_mb.h
index ac20ceede2..6ce94942d5 100644
--- a/src/overlays/actors/ovl_En_Mb/z_en_mb.h
+++ b/src/overlays/actors/ovl_En_Mb/z_en_mb.h
@@ -44,7 +44,7 @@ typedef struct EnMb {
     /* 0x035E */ s8 direction;
     /* 0x0360 */ f32 maxHomeDist;
     /* 0x0364 */ f32 playerDetectionRange;
-    /* 0x0368 */ ColliderCylinder hitbox;
+    /* 0x0368 */ ColliderCylinder bodyCollider;
     /* 0x03B4 */ ColliderQuad attackCollider; // for attacking the player
     /* 0x0434 */ ColliderTris frontShielding; // Moblins don't have shields, but this acts as one
     /* 0x0454 */ ColliderTrisElement frontShieldingTris[2];
diff --git a/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c b/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
index e746b59a31..1e927ba11a 100644
--- a/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
+++ b/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
@@ -120,7 +120,7 @@ void func_80ABBBA8(EnNutsball* this, PlayState* play) {
                 this->collider.base.atFlags &= ~AT_TYPE_ENEMY & ~AT_BOUNCED & ~AT_HIT;
                 this->collider.base.atFlags |= AT_TYPE_PLAYER;
 
-                this->collider.info.toucher.dmgFlags = DMG_DEKU_STICK;
+                this->collider.elem.toucher.dmgFlags = DMG_DEKU_STICK;
                 Matrix_MtxFToYXZRotS(&player->shieldMf, &sp4C, 0);
                 this->actor.world.rot.y = sp4C.y + 0x8000;
                 this->timer = 30;
diff --git a/src/overlays/actors/ovl_En_Ny/z_en_ny.c b/src/overlays/actors/ovl_En_Ny/z_en_ny.c
index 7506a8cbbe..cff5324d64 100644
--- a/src/overlays/actors/ovl_En_Ny/z_en_ny.c
+++ b/src/overlays/actors/ovl_En_Ny/z_en_ny.c
@@ -305,9 +305,9 @@ s32 EnNy_CollisionCheck(EnNy* this, PlayState* play) {
     } else {
         if (this->collider.base.acFlags & AC_HIT) {
             this->collider.base.acFlags &= ~AC_HIT;
-            effectPos.x = this->collider.elements[0].info.bumper.hitPos.x;
-            effectPos.y = this->collider.elements[0].info.bumper.hitPos.y;
-            effectPos.z = this->collider.elements[0].info.bumper.hitPos.z;
+            effectPos.x = this->collider.elements[0].base.bumper.hitPos.x;
+            effectPos.y = this->collider.elements[0].base.bumper.hitPos.y;
+            effectPos.z = this->collider.elements[0].base.bumper.hitPos.z;
             if ((this->unk_1E0 == 0.25f) && (this->unk_1D4 == 0xFF)) {
                 switch (this->actor.colChkInfo.damageEffect) {
                     case 0xE:
diff --git a/src/overlays/actors/ovl_En_Okuta/z_en_okuta.c b/src/overlays/actors/ovl_En_Okuta/z_en_okuta.c
index 62b3806a3d..61d2ea57a2 100644
--- a/src/overlays/actors/ovl_En_Okuta/z_en_okuta.c
+++ b/src/overlays/actors/ovl_En_Okuta/z_en_okuta.c
@@ -490,7 +490,7 @@ void EnOkuta_ProjectileFly(EnOkuta* this, PlayState* play) {
             this->collider.base.atFlags & AT_BOUNCED) {
             this->collider.base.atFlags &= ~(AT_HIT | AT_BOUNCED | AT_TYPE_ENEMY);
             this->collider.base.atFlags |= AT_TYPE_PLAYER;
-            this->collider.info.toucher.dmgFlags = DMG_DEKU_STICK;
+            this->collider.elem.toucher.dmgFlags = DMG_DEKU_STICK;
             Matrix_MtxFToYXZRotS(&player->shieldMf, &shieldRot, 0);
             this->actor.world.rot.y = shieldRot.y + 0x8000;
             this->timer = 30;
@@ -555,7 +555,7 @@ void EnOkuta_UpdateHeadScale(EnOkuta* this) {
 void EnOkuta_ColliderCheck(EnOkuta* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
         if ((this->actor.colChkInfo.damageEffect != 0) || (this->actor.colChkInfo.damage != 0)) {
             Enemy_StartFinishingBlow(play, &this->actor);
             this->actor.colChkInfo.health = 0;
diff --git a/src/overlays/actors/ovl_En_Peehat/z_en_peehat.c b/src/overlays/actors/ovl_En_Peehat/z_en_peehat.c
index b9156239d5..973b02717c 100644
--- a/src/overlays/actors/ovl_En_Peehat/z_en_peehat.c
+++ b/src/overlays/actors/ovl_En_Peehat/z_en_peehat.c
@@ -231,7 +231,7 @@ void EnPeehat_Init(Actor* thisx, PlayState* play) {
             this->colCylinder.dim.radius = 25;
             this->colCylinder.dim.height = 15;
             this->colCylinder.dim.yShift = -5;
-            this->colCylinder.info.bumper.dmgFlags = DMG_ARROW | DMG_SLINGSHOT;
+            this->colCylinder.elem.bumper.dmgFlags = DMG_ARROW | DMG_SLINGSHOT;
             this->colQuad.base.atFlags = AT_ON | AT_TYPE_ENEMY;
             this->colQuad.base.acFlags = AC_ON | AC_TYPE_PLAYER;
             this->actor.naviEnemyId = NAVI_ENEMY_PEAHAT_LARVA;
diff --git a/src/overlays/actors/ovl_En_Po_Field/z_en_po_field.c b/src/overlays/actors/ovl_En_Po_Field/z_en_po_field.c
index 66fb49db79..9c2de64682 100644
--- a/src/overlays/actors/ovl_En_Po_Field/z_en_po_field.c
+++ b/src/overlays/actors/ovl_En_Po_Field/z_en_po_field.c
@@ -263,7 +263,7 @@ void EnPoField_SetupFlee(EnPoField* this) {
 
 void EnPoField_SetupDamage(EnPoField* this) {
     Animation_MorphToPlayOnce(&this->skelAnime, &gPoeFieldDamagedAnim, -6.0f);
-    if (this->collider.info.acHitInfo->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
+    if (this->collider.elem.acHitElem->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
         this->actor.world.rot.y = this->collider.base.ac->world.rot.y;
     } else {
         this->actor.world.rot.y = Actor_WorldYawTowardActor(&this->actor, this->collider.base.ac) + 0x8000;
diff --git a/src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c b/src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c
index bf028ae267..27da379c4d 100644
--- a/src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c
+++ b/src/overlays/actors/ovl_En_Po_Sisters/z_en_po_sisters.c
@@ -209,8 +209,8 @@ void EnPoSisters_Init(Actor* thisx, PlayState* play) {
             func_80AD9AA8(this, play);
         } else {
             this->actor.flags &= ~(ACTOR_FLAG_9 | ACTOR_FLAG_14);
-            this->collider.info.elemType = ELEMTYPE_UNK4;
-            this->collider.info.bumper.dmgFlags |= DMG_DEKU_NUT;
+            this->collider.elem.elemType = ELEMTYPE_UNK4;
+            this->collider.elem.bumper.dmgFlags |= DMG_DEKU_NUT;
             this->collider.base.ocFlags1 = OC1_NONE;
             func_80AD9C24(this, NULL);
         }
@@ -301,7 +301,7 @@ void func_80AD9568(EnPoSisters* this) {
 void func_80AD95D8(EnPoSisters* this) {
     Animation_MorphToPlayOnce(&this->skelAnime, &gPoeSistersDamagedAnim, -3.0f);
     if (this->collider.base.ac != NULL) {
-        this->actor.world.rot.y = (this->collider.info.acHitInfo->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT))
+        this->actor.world.rot.y = (this->collider.elem.acHitElem->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT))
                                       ? this->collider.base.ac->world.rot.y
                                       : Actor_WorldYawTowardActor(&this->actor, this->collider.base.ac) + 0x8000;
     }
@@ -744,7 +744,7 @@ void func_80ADAD54(EnPoSisters* this, PlayState* play) {
 
     if (SkelAnime_Update(&this->skelAnime)) {
         this->unk_22E.a = 0;
-        this->collider.info.bumper.dmgFlags = DMG_MAGIC_ICE | DMG_MAGIC_FIRE | DMG_DEKU_NUT;
+        this->collider.elem.bumper.dmgFlags = DMG_MAGIC_ICE | DMG_MAGIC_FIRE | DMG_DEKU_NUT;
         func_80AD93C4(this);
     } else {
         endFrame = this->skelAnime.endFrame;
@@ -757,7 +757,7 @@ void func_80ADAE6C(EnPoSisters* this, PlayState* play) {
         this->unk_22E.a = 255;
         if (this->unk_194 != 0) {
             this->unk_199 |= 1;
-            this->collider.info.bumper.dmgFlags = (DMG_SWORD | DMG_ARROW | DMG_HAMMER | DMG_MAGIC_ICE | DMG_MAGIC_FIRE |
+            this->collider.elem.bumper.dmgFlags = (DMG_SWORD | DMG_ARROW | DMG_HAMMER | DMG_MAGIC_ICE | DMG_MAGIC_FIRE |
                                                    DMG_HOOKSHOT | DMG_EXPLOSIVE | DMG_DEKU_STICK);
             if (this->unk_19A != 0) {
                 this->unk_19A--;
@@ -1134,7 +1134,7 @@ void func_80ADC10C(EnPoSisters* this, PlayState* play) {
 
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
         if (this->unk_195 != 0) {
             ((EnPoSisters*)this->actor.parent)->unk_19C--;
             Actor_PlaySfx(&this->actor, NA_SE_EN_PO_LAUGH2);
diff --git a/src/overlays/actors/ovl_En_Poh/z_en_poh.c b/src/overlays/actors/ovl_En_Poh/z_en_poh.c
index 16f5d5327f..ee737aaab7 100644
--- a/src/overlays/actors/ovl_En_Poh/z_en_poh.c
+++ b/src/overlays/actors/ovl_En_Poh/z_en_poh.c
@@ -293,7 +293,7 @@ void func_80ADE28C(EnPoh* this) {
     } else {
         Animation_PlayOnce(&this->skelAnime, &gPoeComposerDamagedAnim);
     }
-    if (this->colliderCyl.info.acHitInfo->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
+    if (this->colliderCyl.elem.acHitElem->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
         this->actor.world.rot.y = this->colliderCyl.base.ac->world.rot.y;
     } else {
         this->actor.world.rot.y = Actor_WorldYawTowardActor(&this->actor, this->colliderCyl.base.ac) + 0x8000;
diff --git a/src/overlays/actors/ovl_En_Rd/z_en_rd.c b/src/overlays/actors/ovl_En_Rd/z_en_rd.c
index 1f8e1b84e8..b258cb28bc 100644
--- a/src/overlays/actors/ovl_En_Rd/z_en_rd.c
+++ b/src/overlays/actors/ovl_En_Rd/z_en_rd.c
@@ -801,7 +801,7 @@ void EnRd_UpdateDamage(EnRd* this, PlayState* play) {
         this->damageEffect = this->actor.colChkInfo.damageEffect;
 
         if (this->action != REDEAD_ACTION_RISE_FROM_COFFIN) {
-            Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+            Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
             if (player->unk_844 != 0) {
                 this->unk_31D = player->unk_845;
             }
diff --git a/src/overlays/actors/ovl_En_Reeba/z_en_reeba.c b/src/overlays/actors/ovl_En_Reeba/z_en_reeba.c
index 3fc213e155..642dd155f9 100644
--- a/src/overlays/actors/ovl_En_Reeba/z_en_reeba.c
+++ b/src/overlays/actors/ovl_En_Reeba/z_en_reeba.c
@@ -132,8 +132,8 @@ void EnReeba_Init(Actor* thisx, PlayState* play) {
         // "Reeba Boss Appears %f"
         osSyncPrintf(VT_FGCOL(YELLOW) "☆☆☆☆☆ リーバぼす登場 ☆☆☆☆☆ %f\n" VT_RST, this->scale);
         this->actor.colChkInfo.health = 20;
-        this->collider.info.toucher.effect = 4;
-        this->collider.info.toucher.damage = 16;
+        this->collider.elem.toucher.effect = 4;
+        this->collider.elem.toucher.damage = 16;
         Actor_ChangeCategory(play, &play->actorCtx, &this->actor, ACTORCAT_ENEMY);
     }
 
diff --git a/src/overlays/actors/ovl_En_Rr/z_en_rr.c b/src/overlays/actors/ovl_En_Rr/z_en_rr.c
index dbea771c3d..547a12b7f3 100644
--- a/src/overlays/actors/ovl_En_Rr/z_en_rr.c
+++ b/src/overlays/actors/ovl_En_Rr/z_en_rr.c
@@ -417,9 +417,9 @@ void EnRr_CollisionCheck(EnRr* this, PlayState* play) {
         this->collider2.base.acFlags &= ~AC_HIT;
         // "Kakin" (not sure what this means)
         osSyncPrintf(VT_FGCOL(GREEN) "カキン(%d)！！" VT_RST "\n", this->frameCount);
-        hitPos.x = this->collider2.info.bumper.hitPos.x;
-        hitPos.y = this->collider2.info.bumper.hitPos.y;
-        hitPos.z = this->collider2.info.bumper.hitPos.z;
+        hitPos.x = this->collider2.elem.bumper.hitPos.x;
+        hitPos.y = this->collider2.elem.bumper.hitPos.y;
+        hitPos.z = this->collider2.elem.bumper.hitPos.z;
         CollisionCheck_SpawnShieldParticlesMetal2(play, &hitPos);
     } else {
         if (this->collider1.base.acFlags & AC_HIT) {
@@ -427,9 +427,9 @@ void EnRr_CollisionCheck(EnRr* this, PlayState* play) {
 
             this->collider1.base.acFlags &= ~AC_HIT;
             if (this->actor.colChkInfo.damageEffect != 0) {
-                hitPos.x = this->collider1.info.bumper.hitPos.x;
-                hitPos.y = this->collider1.info.bumper.hitPos.y;
-                hitPos.z = this->collider1.info.bumper.hitPos.z;
+                hitPos.x = this->collider1.elem.bumper.hitPos.x;
+                hitPos.y = this->collider1.elem.bumper.hitPos.y;
+                hitPos.z = this->collider1.elem.bumper.hitPos.z;
                 CollisionCheck_BlueBlood(play, NULL, &hitPos);
             }
             switch (this->actor.colChkInfo.damageEffect) {
diff --git a/src/overlays/actors/ovl_En_Sb/z_en_sb.c b/src/overlays/actors/ovl_En_Sb/z_en_sb.c
index a6eda4e5d0..8f646fcded 100644
--- a/src/overlays/actors/ovl_En_Sb/z_en_sb.c
+++ b/src/overlays/actors/ovl_En_Sb/z_en_sb.c
@@ -388,7 +388,7 @@ s32 EnSb_UpdateDamage(EnSb* this, PlayState* play) {
                 FALLTHROUGH;
             case 15: // explosions, arrow, hammer, ice arrow, light arrow, spirit arrow, shadow arrow
                 if (EnSb_IsVulnerable(this)) {
-                    hitY = this->collider.info.bumper.hitPos.y - this->actor.world.pos.y;
+                    hitY = this->collider.elem.bumper.hitPos.y - this->actor.world.pos.y;
                     yawDiff = this->actor.yawTowardsPlayer - this->actor.shape.rot.y;
                     if ((hitY < 30.0f) && (hitY > 10.0f) && (yawDiff >= -0x1FFF) && (yawDiff < 0x2000)) {
                         Actor_ApplyDamage(&this->actor);
@@ -406,7 +406,7 @@ s32 EnSb_UpdateDamage(EnSb* this, PlayState* play) {
             case 1:  // hookshot/longshot
             case 13: // all sword damage
                 if (EnSb_IsVulnerable(this)) {
-                    hitY = this->collider.info.bumper.hitPos.y - this->actor.world.pos.y;
+                    hitY = this->collider.elem.bumper.hitPos.y - this->actor.world.pos.y;
                     yawDiff = this->actor.yawTowardsPlayer - this->actor.shape.rot.y;
                     if ((hitY < 30.0f) && (hitY > 10.0f) && (yawDiff >= -0x1FFF) && (yawDiff < 0x2000)) {
                         Actor_ApplyDamage(&this->actor);
@@ -430,9 +430,9 @@ s32 EnSb_UpdateDamage(EnSb* this, PlayState* play) {
 
         // if player attack didn't do damage, play recoil sound effect and spawn sparks
         if (!tookDamage) {
-            hitPoint.x = this->collider.info.bumper.hitPos.x;
-            hitPoint.y = this->collider.info.bumper.hitPos.y;
-            hitPoint.z = this->collider.info.bumper.hitPos.z;
+            hitPoint.x = this->collider.elem.bumper.hitPos.x;
+            hitPoint.y = this->collider.elem.bumper.hitPos.y;
+            hitPoint.z = this->collider.elem.bumper.hitPos.z;
             CollisionCheck_SpawnShieldParticlesMetal2(play, &hitPoint);
         }
     }
diff --git a/src/overlays/actors/ovl_En_Shopnuts/z_en_shopnuts.c b/src/overlays/actors/ovl_En_Shopnuts/z_en_shopnuts.c
index e9f0bb3022..406f96ce97 100644
--- a/src/overlays/actors/ovl_En_Shopnuts/z_en_shopnuts.c
+++ b/src/overlays/actors/ovl_En_Shopnuts/z_en_shopnuts.c
@@ -250,7 +250,7 @@ void EnShopnuts_SpawnSalesman(EnShopnuts* this, PlayState* play) {
 void EnShopnuts_ColliderCheck(EnShopnuts* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
         EnShopnuts_SetupSpawnSalesman(this);
     } else if (play->actorCtx.unk_02 != 0) {
         EnShopnuts_SetupSpawnSalesman(this);
diff --git a/src/overlays/actors/ovl_En_Skb/z_en_skb.c b/src/overlays/actors/ovl_En_Skb/z_en_skb.c
index d7a3ab86d5..3fd564e7ab 100644
--- a/src/overlays/actors/ovl_En_Skb/z_en_skb.c
+++ b/src/overlays/actors/ovl_En_Skb/z_en_skb.c
@@ -459,7 +459,7 @@ void EnSkb_CheckDamage(EnSkb* this, PlayState* play) {
             this->collider.base.acFlags &= ~AC_HIT;
             if (this->actor.colChkInfo.damageEffect != 6) {
                 this->lastDamageEffect = this->actor.colChkInfo.damageEffect;
-                Actor_SetDropFlag(&this->actor, &this->collider.elements[1].info, true);
+                Actor_SetDropFlag(&this->actor, &this->collider.elements[1].base, true);
                 this->setColliderAT = false;
                 if (this->actor.colChkInfo.damageEffect == 1) {
                     if (this->actionState != SKB_BEHAVIOR_STUNNED) {
diff --git a/src/overlays/actors/ovl_En_Skj/z_en_skj.c b/src/overlays/actors/ovl_En_Skj/z_en_skj.c
index 1e4ce3ffbc..24a6f12a62 100644
--- a/src/overlays/actors/ovl_En_Skj/z_en_skj.c
+++ b/src/overlays/actors/ovl_En_Skj/z_en_skj.c
@@ -581,9 +581,9 @@ s32 EnSkj_CollisionCheck(EnSkj* this, PlayState* play) {
         this->collider.base.acFlags &= ~AC_HIT;
         switch (this->actor.colChkInfo.damageEffect) {
             case 0xF:
-                effectPos.x = this->collider.info.bumper.hitPos.x;
-                effectPos.y = this->collider.info.bumper.hitPos.y;
-                effectPos.z = this->collider.info.bumper.hitPos.z;
+                effectPos.x = this->collider.elem.bumper.hitPos.x;
+                effectPos.y = this->collider.elem.bumper.hitPos.y;
+                effectPos.z = this->collider.elem.bumper.hitPos.z;
 
                 EnSkj_SpawnBlood(play, &effectPos);
                 EffectSsHitMark_SpawnFixedScale(play, 1, &effectPos);
diff --git a/src/overlays/actors/ovl_En_Ssh/z_en_ssh.c b/src/overlays/actors/ovl_En_Ssh/z_en_ssh.c
index 424e6bb258..61fbe3fe85 100644
--- a/src/overlays/actors/ovl_En_Ssh/z_en_ssh.c
+++ b/src/overlays/actors/ovl_En_Ssh/z_en_ssh.c
@@ -200,15 +200,15 @@ void EnSsh_InitColliders(EnSsh* this, PlayState* play) {
         Collider_SetCylinder(play, &this->colCylinder[i], &this->actor, cylinders[i]);
     }
 
-    this->colCylinder[0].info.bumper.dmgFlags =
+    this->colCylinder[0].elem.bumper.dmgFlags =
         DMG_ARROW | DMG_MAGIC_FIRE | DMG_HOOKSHOT | DMG_HAMMER_SWING | DMG_EXPLOSIVE | DMG_DEKU_NUT;
-    this->colCylinder[1].info.bumper.dmgFlags =
+    this->colCylinder[1].elem.bumper.dmgFlags =
         DMG_DEFAULT & ~(DMG_ARROW | DMG_MAGIC_FIRE | DMG_HOOKSHOT | DMG_HAMMER_SWING | DMG_EXPLOSIVE | DMG_DEKU_NUT) &
         ~(DMG_MAGIC_LIGHT | DMG_MAGIC_ICE);
     this->colCylinder[2].base.colType = COLTYPE_METAL;
-    this->colCylinder[2].info.bumperFlags = BUMP_ON | BUMP_HOOKABLE | BUMP_NO_AT_INFO;
-    this->colCylinder[2].info.elemType = ELEMTYPE_UNK2;
-    this->colCylinder[2].info.bumper.dmgFlags =
+    this->colCylinder[2].elem.bumperFlags = BUMP_ON | BUMP_HOOKABLE | BUMP_NO_AT_INFO;
+    this->colCylinder[2].elem.elemType = ELEMTYPE_UNK2;
+    this->colCylinder[2].elem.bumper.dmgFlags =
         DMG_DEFAULT & ~(DMG_ARROW | DMG_MAGIC_FIRE | DMG_HOOKSHOT | DMG_HAMMER_SWING | DMG_EXPLOSIVE | DMG_DEKU_NUT);
 
     CollisionCheck_SetInfo2(&this->actor.colChkInfo, DamageTable_Get(2), &sColChkInfoInit);
@@ -434,17 +434,17 @@ void EnSsh_Sway(EnSsh* this) {
 }
 
 void EnSsh_CheckBodyStickHit(EnSsh* this, PlayState* play) {
-    ColliderInfo* info = &this->colCylinder[0].info;
+    ColliderElement* elem = &this->colCylinder[0].elem;
     Player* player = GET_PLAYER(play);
 
     if (player->unk_860 != 0) {
-        info->bumper.dmgFlags |= DMG_DEKU_STICK;
-        this->colCylinder[1].info.bumper.dmgFlags &= ~DMG_DEKU_STICK;
-        this->colCylinder[2].info.bumper.dmgFlags &= ~DMG_DEKU_STICK;
+        elem->bumper.dmgFlags |= DMG_DEKU_STICK;
+        this->colCylinder[1].elem.bumper.dmgFlags &= ~DMG_DEKU_STICK;
+        this->colCylinder[2].elem.bumper.dmgFlags &= ~DMG_DEKU_STICK;
     } else {
-        info->bumper.dmgFlags &= ~DMG_DEKU_STICK;
-        this->colCylinder[1].info.bumper.dmgFlags |= DMG_DEKU_STICK;
-        this->colCylinder[2].info.bumper.dmgFlags |= DMG_DEKU_STICK;
+        elem->bumper.dmgFlags &= ~DMG_DEKU_STICK;
+        this->colCylinder[1].elem.bumper.dmgFlags |= DMG_DEKU_STICK;
+        this->colCylinder[2].elem.bumper.dmgFlags |= DMG_DEKU_STICK;
     }
 }
 
diff --git a/src/overlays/actors/ovl_En_St/z_en_st.c b/src/overlays/actors/ovl_En_St/z_en_st.c
index bd4e74486e..a65aca9455 100644
--- a/src/overlays/actors/ovl_En_St/z_en_st.c
+++ b/src/overlays/actors/ovl_En_St/z_en_st.c
@@ -285,16 +285,16 @@ void EnSt_InitColliders(EnSt* this, PlayState* play) {
         Collider_SetCylinder(play, &this->colCylinder[i], &this->actor, cylinders[i]);
     }
 
-    this->colCylinder[0].info.bumper.dmgFlags =
+    this->colCylinder[0].elem.bumper.dmgFlags =
         DMG_MAGIC_FIRE | DMG_ARROW | DMG_HOOKSHOT | DMG_HAMMER_SWING | DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT;
-    this->colCylinder[1].info.bumper.dmgFlags =
+    this->colCylinder[1].elem.bumper.dmgFlags =
         DMG_DEFAULT &
         ~(DMG_MAGIC_FIRE | DMG_ARROW | DMG_HOOKSHOT | DMG_HAMMER_SWING | DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT) &
         ~(DMG_MAGIC_LIGHT | DMG_MAGIC_ICE);
     this->colCylinder[2].base.colType = COLTYPE_METAL;
-    this->colCylinder[2].info.bumperFlags = BUMP_ON | BUMP_HOOKABLE | BUMP_NO_AT_INFO;
-    this->colCylinder[2].info.elemType = ELEMTYPE_UNK2;
-    this->colCylinder[2].info.bumper.dmgFlags =
+    this->colCylinder[2].elem.bumperFlags = BUMP_ON | BUMP_HOOKABLE | BUMP_NO_AT_INFO;
+    this->colCylinder[2].elem.elemType = ELEMTYPE_UNK2;
+    this->colCylinder[2].elem.bumper.dmgFlags =
         DMG_DEFAULT &
         ~(DMG_MAGIC_FIRE | DMG_ARROW | DMG_HOOKSHOT | DMG_HAMMER_SWING | DMG_BOOMERANG | DMG_EXPLOSIVE | DMG_DEKU_NUT);
 
@@ -305,17 +305,17 @@ void EnSt_InitColliders(EnSt* this, PlayState* play) {
 }
 
 void EnSt_CheckBodyStickHit(EnSt* this, PlayState* play) {
-    ColliderInfo* body = &this->colCylinder[0].info;
+    ColliderElement* bodyElem = &this->colCylinder[0].elem;
     Player* player = GET_PLAYER(play);
 
     if (player->unk_860 != 0) {
-        body->bumper.dmgFlags |= DMG_DEKU_STICK;
-        this->colCylinder[1].info.bumper.dmgFlags &= ~DMG_DEKU_STICK;
-        this->colCylinder[2].info.bumper.dmgFlags &= ~DMG_DEKU_STICK;
+        bodyElem->bumper.dmgFlags |= DMG_DEKU_STICK;
+        this->colCylinder[1].elem.bumper.dmgFlags &= ~DMG_DEKU_STICK;
+        this->colCylinder[2].elem.bumper.dmgFlags &= ~DMG_DEKU_STICK;
     } else {
-        body->bumper.dmgFlags &= ~DMG_DEKU_STICK;
-        this->colCylinder[1].info.bumper.dmgFlags |= DMG_DEKU_STICK;
-        this->colCylinder[2].info.bumper.dmgFlags |= DMG_DEKU_STICK;
+        bodyElem->bumper.dmgFlags &= ~DMG_DEKU_STICK;
+        this->colCylinder[1].elem.bumper.dmgFlags |= DMG_DEKU_STICK;
+        this->colCylinder[2].elem.bumper.dmgFlags |= DMG_DEKU_STICK;
     }
 }
 
@@ -431,14 +431,14 @@ s32 EnSt_CheckHitBackside(EnSt* this, PlayState* play) {
     if (cyl->base.acFlags & AC_HIT) {
         cyl->base.acFlags &= ~AC_HIT;
         hit = true;
-        flags |= cyl->info.acHitInfo->toucher.dmgFlags;
+        flags |= cyl->elem.acHitElem->toucher.dmgFlags;
     }
 
     cyl = &this->colCylinder[1];
     if (cyl->base.acFlags & AC_HIT) {
         cyl->base.acFlags &= ~AC_HIT;
         hit = true;
-        flags |= cyl->info.acHitInfo->toucher.dmgFlags;
+        flags |= cyl->elem.acHitElem->toucher.dmgFlags;
     }
 
     if (!hit) {
diff --git a/src/overlays/actors/ovl_En_Sw/z_en_sw.c b/src/overlays/actors/ovl_En_Sw/z_en_sw.c
index 78df133bd9..240beec6c4 100644
--- a/src/overlays/actors/ovl_En_Sw/z_en_sw.c
+++ b/src/overlays/actors/ovl_En_Sw/z_en_sw.c
@@ -283,7 +283,7 @@ void EnSw_Init(Actor* thisx, PlayState* play) {
             this->actor.scale.x = 0.0f;
             FALLTHROUGH;
         case 1:
-            this->collider.elements[0].info.toucher.damage *= 2;
+            this->collider.elements[0].base.toucher.damage *= 2;
             this->actor.naviEnemyId = NAVI_ENEMY_GOLD_SKULLTULA;
             this->actor.colChkInfo.health *= 2;
             this->actor.flags &= ~ACTOR_FLAG_0;
@@ -538,15 +538,15 @@ void func_80B0D590(EnSw* this, PlayState* play) {
 
     if (((this->actor.params & 0xE000) >> 0xD) == 2) {
         if (this->actor.scale.x < 0.0139999995f) {
-            this->collider.elements[0].info.toucherFlags = TOUCH_NONE;
-            this->collider.elements[0].info.bumperFlags = BUMP_NONE;
-            this->collider.elements[0].info.ocElemFlags = OCELEM_NONE;
+            this->collider.elements[0].base.toucherFlags = TOUCH_NONE;
+            this->collider.elements[0].base.bumperFlags = BUMP_NONE;
+            this->collider.elements[0].base.ocElemFlags = OCELEM_NONE;
         }
 
         if (this->actor.scale.x >= 0.0139999995f) {
-            this->collider.elements[0].info.toucherFlags = TOUCH_ON;
-            this->collider.elements[0].info.bumperFlags = BUMP_ON;
-            this->collider.elements[0].info.ocElemFlags = OCELEM_ON;
+            this->collider.elements[0].base.toucherFlags = TOUCH_ON;
+            this->collider.elements[0].base.bumperFlags = BUMP_ON;
+            this->collider.elements[0].base.ocElemFlags = OCELEM_ON;
         }
 
         Math_ApproachF(&this->actor.scale.x, !IS_DAY ? 0.02f : 0.0f, 0.2f, 0.01f);
diff --git a/src/overlays/actors/ovl_En_Test/z_en_test.c b/src/overlays/actors/ovl_En_Test/z_en_test.c
index 63a0351e32..40f36cc669 100644
--- a/src/overlays/actors/ovl_En_Test/z_en_test.c
+++ b/src/overlays/actors/ovl_En_Test/z_en_test.c
@@ -898,7 +898,7 @@ void EnTest_SetupSlashDown(EnTest* this) {
     this->unk_7C8 = 0x10;
     this->actor.speed = 0.0f;
     EnTest_SetupAction(this, EnTest_SlashDown);
-    this->swordCollider.info.toucher.damage = 16;
+    this->swordCollider.elem.toucher.damage = 16;
 
     if (this->unk_7DE != 0) {
         this->unk_7DE = 3;
@@ -995,7 +995,7 @@ void EnTest_SetupSlashUp(EnTest* this) {
     Animation_PlayOnce(&this->skelAnime, &gStalfosUpSlashAnim);
     this->swordCollider.base.atFlags &= ~AT_BOUNCED;
     this->unk_7C8 = 0x11;
-    this->swordCollider.info.toucher.damage = 16;
+    this->swordCollider.elem.toucher.damage = 16;
     this->actor.speed = 0.0f;
     EnTest_SetupAction(this, EnTest_SlashUp);
 
@@ -1084,7 +1084,7 @@ void EnTest_SetupJumpslash(EnTest* this) {
     this->actor.world.rot.y = this->actor.shape.rot.y;
     this->swordCollider.base.atFlags &= ~AT_BOUNCED;
     EnTest_SetupAction(this, EnTest_Jumpslash);
-    this->swordCollider.info.toucher.damage = 32;
+    this->swordCollider.elem.toucher.damage = 32;
 
     if (this->unk_7DE != 0) {
         this->unk_7DE = 3;
@@ -1670,7 +1670,7 @@ void EnTest_UpdateDamage(EnTest* this, PlayState* play) {
             }
             this->unk_7DC = player->unk_845;
             this->actor.world.rot.y = this->actor.yawTowardsPlayer;
-            Actor_SetDropFlag(&this->actor, &this->bodyCollider.info, false);
+            Actor_SetDropFlag(&this->actor, &this->bodyCollider.elem, false);
             Audio_StopSfxByPosAndId(&this->actor.projectedPos, NA_SE_EN_STAL_WARAU);
 
             if ((this->actor.colChkInfo.damageEffect == STALFOS_DMGEFF_STUN) ||
diff --git a/src/overlays/actors/ovl_En_Tite/z_en_tite.c b/src/overlays/actors/ovl_En_Tite/z_en_tite.c
index d1aeb1e721..03277a73d7 100644
--- a/src/overlays/actors/ovl_En_Tite/z_en_tite.c
+++ b/src/overlays/actors/ovl_En_Tite/z_en_tite.c
@@ -355,7 +355,7 @@ void EnTite_Attack(EnTite* this, PlayState* play) {
             }
             break;
         case TEKTITE_MID_LUNGE:
-            // Generate sparkles at feet upon landing, set jumping animation and hurtbox and check if hit player
+            // Generate sparkles at feet upon landing, set jumping animation and attack collider and check if hit player
             if (this->actor.velocity.y >= 5.0f) {
                 if (this->actor.bgCheckFlags & BGCHECKFLAG_GROUND) {
                     func_800355B8(play, &this->frontLeftFootPos);
@@ -852,7 +852,7 @@ void EnTite_CheckDamage(Actor* thisx, PlayState* play) {
         this->collider.base.acFlags &= ~AC_HIT;
         if (thisx->colChkInfo.damageEffect != 0xE) { // Immune to fire magic
             this->damageEffect = thisx->colChkInfo.damageEffect;
-            Actor_SetDropFlag(thisx, &this->collider.elements[0].info, false);
+            Actor_SetDropFlag(thisx, &this->collider.elements[0].base, false);
             // Stun if Tektite hit by nut, boomerang, hookshot, ice arrow or ice magic
             if ((thisx->colChkInfo.damageEffect == 1) || (thisx->colChkInfo.damageEffect == 0xF)) {
                 if (this->action != TEKTITE_STUNNED) {
diff --git a/src/overlays/actors/ovl_En_Torch2/z_en_torch2.c b/src/overlays/actors/ovl_En_Torch2/z_en_torch2.c
index a5f86c6361..24eef2901e 100644
--- a/src/overlays/actors/ovl_En_Torch2/z_en_torch2.c
+++ b/src/overlays/actors/ovl_En_Torch2/z_en_torch2.c
@@ -104,8 +104,8 @@ void EnTorch2_Init(Actor* thisx, PlayState* play2) {
     this->meleeWeaponQuads[0].base.atFlags = this->meleeWeaponQuads[1].base.atFlags = AT_ON | AT_TYPE_ENEMY;
     this->meleeWeaponQuads[0].base.acFlags = this->meleeWeaponQuads[1].base.acFlags = AC_ON | AC_HARD | AC_TYPE_PLAYER;
     this->meleeWeaponQuads[0].base.colType = this->meleeWeaponQuads[1].base.colType = COLTYPE_METAL;
-    this->meleeWeaponQuads[0].info.toucher.damage = this->meleeWeaponQuads[1].info.toucher.damage = 8;
-    this->meleeWeaponQuads[0].info.bumperFlags = this->meleeWeaponQuads[1].info.bumperFlags = BUMP_ON;
+    this->meleeWeaponQuads[0].elem.toucher.damage = this->meleeWeaponQuads[1].elem.toucher.damage = 8;
+    this->meleeWeaponQuads[0].elem.bumperFlags = this->meleeWeaponQuads[1].elem.bumperFlags = BUMP_ON;
     this->shieldQuad.base.atFlags = AT_ON | AT_TYPE_ENEMY;
     this->shieldQuad.base.acFlags = AC_ON | AC_HARD | AC_TYPE_PLAYER;
     this->actor.colChkInfo.damageTable = &sDamageTable;
@@ -599,7 +599,7 @@ void EnTorch2_Update(Actor* thisx, PlayState* play2) {
                 this->unk_8A8 = 6.0f;
                 this->unk_8A4 = 8.0f;
                 this->unk_8A2 = this->actor.yawTowardsPlayer + 0x8000;
-                Actor_SetDropFlag(&this->actor, &this->cylinder.info, true);
+                Actor_SetDropFlag(&this->actor, &this->cylinder.elem, true);
                 this->stateFlags3 &= ~PLAYER_STATE3_2;
                 this->stateFlags3 |= PLAYER_STATE3_0;
                 sActionState = ENTORCH2_DAMAGE;
@@ -698,10 +698,10 @@ void EnTorch2_Update(Actor* thisx, PlayState* play2) {
     }
     if (this->invincibilityTimer != 0) {
         this->cylinder.base.colType = COLTYPE_NONE;
-        this->cylinder.info.elemType = ELEMTYPE_UNK5;
+        this->cylinder.elem.elemType = ELEMTYPE_UNK5;
     } else {
         this->cylinder.base.colType = COLTYPE_HIT5;
-        this->cylinder.info.elemType = ELEMTYPE_UNK1;
+        this->cylinder.elem.elemType = ELEMTYPE_UNK1;
     }
     /*
      * Handles the jump movement onto Link's sword. Dark Link doesn't move during the
diff --git a/src/overlays/actors/ovl_En_Vali/z_en_vali.c b/src/overlays/actors/ovl_En_Vali/z_en_vali.c
index 60d7204ec7..2af941834e 100644
--- a/src/overlays/actors/ovl_En_Vali/z_en_vali.c
+++ b/src/overlays/actors/ovl_En_Vali/z_en_vali.c
@@ -258,7 +258,7 @@ void EnVali_SetupStunned(EnVali* this) {
     this->timer = 80;
     this->actor.velocity.y = 0.0f;
     Actor_SetColorFilter(&this->actor, COLORFILTER_COLORFLAG_BLUE, 255, COLORFILTER_BUFFLAG_XLU, 80);
-    this->bodyCollider.info.bumper.effect = 0;
+    this->bodyCollider.elem.bumper.effect = 0;
     Actor_PlaySfx(&this->actor, NA_SE_EN_GOMA_JR_FREEZE);
     this->actor.velocity.y = 1.0f;
     this->actionFunc = EnVali_Stunned;
@@ -448,7 +448,7 @@ void EnVali_Stunned(EnVali* this, PlayState* play) {
     }
 
     if (this->timer == 0) {
-        this->bodyCollider.info.bumper.effect = 1; // Shock?
+        this->bodyCollider.elem.bumper.effect = 1; // Shock?
         EnVali_SetupFloatIdle(this);
     }
 }
@@ -496,7 +496,7 @@ void EnVali_ReturnToLurk(EnVali* this, PlayState* play) {
 void EnVali_UpdateDamage(EnVali* this, PlayState* play) {
     if (this->bodyCollider.base.acFlags & AC_HIT) {
         this->bodyCollider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->bodyCollider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->bodyCollider.elem, true);
 
         if ((this->actor.colChkInfo.damageEffect != BARI_DMGEFF_NONE) || (this->actor.colChkInfo.damage != 0)) {
             if (Actor_ApplyDamage(&this->actor) == 0) {
diff --git a/src/overlays/actors/ovl_En_Wallmas/z_en_wallmas.c b/src/overlays/actors/ovl_En_Wallmas/z_en_wallmas.c
index 4f0f89747e..11e0c9b11a 100644
--- a/src/overlays/actors/ovl_En_Wallmas/z_en_wallmas.c
+++ b/src/overlays/actors/ovl_En_Wallmas/z_en_wallmas.c
@@ -219,7 +219,7 @@ void EnWallmas_SetupReturnToCeiling(EnWallmas* this) {
 
 void EnWallmas_SetupTakeDamage(EnWallmas* this) {
     Animation_MorphToPlayOnce(&this->skelAnime, &gWallmasterDamageAnim, -3.0f);
-    if (this->collider.info.acHitInfo->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
+    if (this->collider.elem.acHitElem->toucher.dmgFlags & (DMG_ARROW | DMG_SLINGSHOT)) {
         this->actor.world.rot.y = this->collider.base.ac->world.rot.y;
     } else {
         this->actor.world.rot.y = Actor_WorldYawTowardActor(&this->actor, this->collider.base.ac) + 0x8000;
@@ -507,7 +507,7 @@ void EnWallmas_Stun(EnWallmas* this, PlayState* play) {
 void EnWallmas_ColUpdate(EnWallmas* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
         if ((this->actor.colChkInfo.damageEffect != 0) || (this->actor.colChkInfo.damage != 0)) {
             if (Actor_ApplyDamage(&this->actor) == 0) {
                 Enemy_StartFinishingBlow(play, &this->actor);
diff --git a/src/overlays/actors/ovl_En_Weiyer/z_en_weiyer.c b/src/overlays/actors/ovl_En_Weiyer/z_en_weiyer.c
index 759bf7ca02..d5e321ff50 100644
--- a/src/overlays/actors/ovl_En_Weiyer/z_en_weiyer.c
+++ b/src/overlays/actors/ovl_En_Weiyer/z_en_weiyer.c
@@ -561,7 +561,7 @@ void func_80B3349C(EnWeiyer* this, PlayState* play) {
 void func_80B3368C(EnWeiyer* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        Actor_SetDropFlag(&this->actor, &this->collider.info, true);
+        Actor_SetDropFlag(&this->actor, &this->collider.elem, true);
 
         if ((this->actor.colChkInfo.damageEffect != 0) || (this->actor.colChkInfo.damage != 0)) {
             if (this->actor.colChkInfo.damageEffect == 1) {
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 a07cf7aa3c..7fca408f7f 100644
--- a/src/overlays/actors/ovl_En_Wf/z_en_wf.c
+++ b/src/overlays/actors/ovl_En_Wf/z_en_wf.c
@@ -241,7 +241,7 @@ void EnWf_Init(Actor* thisx, PlayState* play) {
         SkelAnime_InitFlex(play, &this->skelAnime, &gWolfosWhiteSkel, &gWolfosWaitingAnim, this->jointTable,
                            this->morphTable, WOLFOS_LIMB_MAX);
         Actor_SetScale(thisx, 0.01f);
-        this->colliderSpheres.elements[0].info.toucher.damage = this->colliderSpheres.elements[1].info.toucher.damage =
+        this->colliderSpheres.elements[0].base.toucher.damage = this->colliderSpheres.elements[1].base.toucher.damage =
             8;
         thisx->naviEnemyId = NAVI_ENEMY_WHITE_WOLFOS;
     }
@@ -1266,7 +1266,7 @@ void EnWf_UpdateDamage(EnWf* this, PlayState* play) {
 
             if (this->actor.colChkInfo.damageEffect != ENWF_DMGEFF_ICE_MAGIC) {
                 this->damageEffect = this->actor.colChkInfo.damageEffect;
-                Actor_SetDropFlag(&this->actor, &this->colliderCylinderBody.info, true);
+                Actor_SetDropFlag(&this->actor, &this->colliderCylinderBody.elem, true);
                 this->slashStatus = 0;
 
                 if ((this->actor.colChkInfo.damageEffect == ENWF_DMGEFF_STUN) ||
diff --git a/src/overlays/actors/ovl_En_Wonder_Item/z_en_wonder_item.c b/src/overlays/actors/ovl_En_Wonder_Item/z_en_wonder_item.c
index e60e3f40ac..f475b77e92 100644
--- a/src/overlays/actors/ovl_En_Wonder_Item/z_en_wonder_item.c
+++ b/src/overlays/actors/ovl_En_Wonder_Item/z_en_wonder_item.c
@@ -159,7 +159,7 @@ void EnWonderItem_Init(Actor* thisx, PlayState* play) {
             colTypeIndex = this->actor.world.rot.z & 0xFF;
             Collider_InitCylinder(play, &this->collider);
             Collider_SetCylinder(play, &this->collider, &this->actor, &sCylinderInit);
-            this->collider.info.bumper.dmgFlags = damageFlags[colTypeIndex];
+            this->collider.elem.bumper.dmgFlags = damageFlags[colTypeIndex];
             this->collider.dim.radius = 20;
             this->collider.dim.height = 30;
             this->updateFunc = EnWonderItem_InteractSwitch;
@@ -188,7 +188,7 @@ void EnWonderItem_Init(Actor* thisx, PlayState* play) {
         case WONDERITEM_BOMB_SOLDIER:
             Collider_InitCylinder(play, &this->collider);
             Collider_SetCylinder(play, &this->collider, &this->actor, &sCylinderInit);
-            this->collider.info.bumper.dmgFlags = DMG_SLINGSHOT;
+            this->collider.elem.bumper.dmgFlags = DMG_SLINGSHOT;
             this->unkPos = this->actor.world.pos;
             this->collider.dim.radius = 35;
             this->collider.dim.height = 75;
diff --git a/src/overlays/actors/ovl_En_Yabusame_Mark/z_en_yabusame_mark.c b/src/overlays/actors/ovl_En_Yabusame_Mark/z_en_yabusame_mark.c
index e70587fd10..741f7d59b8 100644
--- a/src/overlays/actors/ovl_En_Yabusame_Mark/z_en_yabusame_mark.c
+++ b/src/overlays/actors/ovl_En_Yabusame_Mark/z_en_yabusame_mark.c
@@ -128,9 +128,9 @@ void func_80B42F74(EnYabusameMark* this, PlayState* play) {
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
 
-        arrowHitPos.x = this->collider.info.bumper.hitPos.x;
-        arrowHitPos.y = this->collider.info.bumper.hitPos.y;
-        arrowHitPos.z = this->collider.info.bumper.hitPos.z;
+        arrowHitPos.x = this->collider.elem.bumper.hitPos.x;
+        arrowHitPos.y = this->collider.elem.bumper.hitPos.y;
+        arrowHitPos.z = this->collider.elem.bumper.hitPos.z;
 
         effectVelocity.y = 15.0f;
 
diff --git a/src/overlays/actors/ovl_En_Zf/z_en_zf.c b/src/overlays/actors/ovl_En_Zf/z_en_zf.c
index 1f8fb35b73..9d1c93926f 100644
--- a/src/overlays/actors/ovl_En_Zf/z_en_zf.c
+++ b/src/overlays/actors/ovl_En_Zf/z_en_zf.c
@@ -2000,7 +2000,7 @@ void EnZf_UpdateDamage(EnZf* this, PlayState* play) {
              (D_80B4A1B4 != this->actor.params)) &&
             (this->actor.colChkInfo.damageEffect != ENZF_DMGEFF_IMMUNE)) {
             this->damageEffect = this->actor.colChkInfo.damageEffect;
-            Actor_SetDropFlag(&this->actor, &this->bodyCollider.info, false);
+            Actor_SetDropFlag(&this->actor, &this->bodyCollider.elem, false);
 
             if ((this->actor.colChkInfo.damageEffect == ENZF_DMGEFF_STUN) ||
                 (this->actor.colChkInfo.damageEffect == ENZF_DMGEFF_ICE)) {
diff --git a/src/overlays/actors/ovl_Magic_Fire/z_magic_fire.c b/src/overlays/actors/ovl_Magic_Fire/z_magic_fire.c
index 03918aeed7..0e32deee95 100644
--- a/src/overlays/actors/ovl_Magic_Fire/z_magic_fire.c
+++ b/src/overlays/actors/ovl_Magic_Fire/z_magic_fire.c
@@ -133,9 +133,9 @@ void MagicFire_Update(Actor* thisx, PlayState* play) {
     }
 
     if (this->action == DF_ACTION_EXPAND_SLOWLY) {
-        this->collider.info.toucher.damage = this->actionTimer + 25;
+        this->collider.elem.toucher.damage = this->actionTimer + 25;
     } else if (this->action == DF_ACTION_STOP_EXPANDING) {
-        this->collider.info.toucher.damage = this->actionTimer;
+        this->collider.elem.toucher.damage = this->actionTimer;
     }
     Collider_UpdateCylinder(&this->actor, &this->collider);
     this->collider.dim.radius = (this->actor.scale.x * 325.0f);
diff --git a/src/overlays/actors/ovl_Obj_Bombiwa/z_obj_bombiwa.c b/src/overlays/actors/ovl_Obj_Bombiwa/z_obj_bombiwa.c
index c5456421d4..8428f34675 100644
--- a/src/overlays/actors/ovl_Obj_Bombiwa/z_obj_bombiwa.c
+++ b/src/overlays/actors/ovl_Obj_Bombiwa/z_obj_bombiwa.c
@@ -125,7 +125,7 @@ void ObjBombiwa_Update(Actor* thisx, PlayState* play) {
     s32 pad;
 
     if ((func_80033684(play, &this->actor) != NULL) ||
-        ((this->collider.base.acFlags & AC_HIT) && (this->collider.info.acHitInfo->toucher.dmgFlags & DMG_HAMMER))) {
+        ((this->collider.base.acFlags & AC_HIT) && (this->collider.elem.acHitElem->toucher.dmgFlags & DMG_HAMMER))) {
         ObjBombiwa_Break(this, play);
         Flags_SetSwitch(play, this->actor.params & 0x3F);
         SfxSource_PlaySfxAtFixedWorldPos(play, &this->actor.world.pos, 80, NA_SE_EV_WALL_BROKEN);
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 08a6f5bfe9..69b311e486 100644
--- a/src/overlays/actors/ovl_Obj_Comb/z_obj_comb.c
+++ b/src/overlays/actors/ovl_Obj_Comb/z_obj_comb.c
@@ -176,7 +176,7 @@ void ObjComb_Wait(ObjComb* this, PlayState* play) {
 
     if (this->collider.base.acFlags & AC_HIT) {
         this->collider.base.acFlags &= ~AC_HIT;
-        dmgFlags = this->collider.elements[0].info.acHitInfo->toucher.dmgFlags;
+        dmgFlags = this->collider.elements[0].base.acHitElem->toucher.dmgFlags;
         if (dmgFlags & (DMG_HAMMER | DMG_ARROW | DMG_SLINGSHOT | DMG_DEKU_STICK)) {
             this->unk_1B0 = 1500;
         } else {
diff --git a/src/overlays/actors/ovl_Obj_Hamishi/z_obj_hamishi.c b/src/overlays/actors/ovl_Obj_Hamishi/z_obj_hamishi.c
index c88dad54c2..cae5d27338 100644
--- a/src/overlays/actors/ovl_Obj_Hamishi/z_obj_hamishi.c
+++ b/src/overlays/actors/ovl_Obj_Hamishi/z_obj_hamishi.c
@@ -170,7 +170,7 @@ void ObjHamishi_Update(Actor* thisx, PlayState* play) {
 
     ObjHamishi_Shake(this);
 
-    if ((this->collider.base.acFlags & AC_HIT) && (this->collider.info.acHitInfo->toucher.dmgFlags & DMG_HAMMER)) {
+    if ((this->collider.base.acFlags & AC_HIT) && (this->collider.elem.acHitElem->toucher.dmgFlags & DMG_HAMMER)) {
         this->collider.base.acFlags &= ~AC_HIT;
         this->hitCount++;
         if (this->hitCount < 2) {
diff --git a/src/overlays/actors/ovl_Obj_Ice_Poly/z_obj_ice_poly.c b/src/overlays/actors/ovl_Obj_Ice_Poly/z_obj_ice_poly.c
index a79fc0845d..04a3096d5c 100644
--- a/src/overlays/actors/ovl_Obj_Ice_Poly/z_obj_ice_poly.c
+++ b/src/overlays/actors/ovl_Obj_Ice_Poly/z_obj_ice_poly.c
@@ -117,7 +117,7 @@ void ObjIcePoly_Idle(ObjIcePoly* this, PlayState* play) {
     Vec3f pos;
 
     if (this->colliderIce.base.acFlags & AC_HIT) {
-        this->meltTimer = -this->colliderIce.info.acHitInfo->toucher.damage;
+        this->meltTimer = -this->colliderIce.elem.acHitElem->toucher.damage;
         this->actor.focus.rot.y = this->actor.yawTowardsPlayer;
         OnePointCutscene_Init(play, 5120, 40, &this->actor, CAM_ID_MAIN);
         this->actionFunc = ObjIcePoly_Melt;
diff --git a/src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c b/src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c
index 4139ed1b75..9e1c15429a 100644
--- a/src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c
+++ b/src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c
@@ -171,7 +171,7 @@ void ObjSyokudai_Update(Actor* thisx, PlayState* play2) {
             }
         }
         if (this->colliderFlame.base.acFlags & AC_HIT) {
-            dmgFlags = this->colliderFlame.info.acHitInfo->toucher.dmgFlags;
+            dmgFlags = this->colliderFlame.elem.acHitElem->toucher.dmgFlags;
             if (dmgFlags & (DMG_FIRE | DMG_ARROW_NORMAL)) {
                 interactionType = 1;
             }
@@ -197,7 +197,7 @@ void ObjSyokudai_Update(Actor* thisx, PlayState* play2) {
                     arrow = (EnArrow*)this->colliderFlame.base.ac;
                     if ((arrow->actor.update != NULL) && (arrow->actor.id == ACTOR_EN_ARROW)) {
                         arrow->actor.params = 0;
-                        arrow->collider.info.toucher.dmgFlags = DMG_ARROW_FIRE;
+                        arrow->collider.elem.toucher.dmgFlags = DMG_ARROW_FIRE;
                     }
                 }
                 if ((0 <= this->litTimer) && (this->litTimer < (50 * litTimeScale + 100)) && (torchType != 0)) {
diff --git a/src/overlays/actors/ovl_Obj_Tsubo/z_obj_tsubo.c b/src/overlays/actors/ovl_Obj_Tsubo/z_obj_tsubo.c
index 1152e98b93..e99e3a673d 100644
--- a/src/overlays/actors/ovl_Obj_Tsubo/z_obj_tsubo.c
+++ b/src/overlays/actors/ovl_Obj_Tsubo/z_obj_tsubo.c
@@ -246,7 +246,7 @@ void ObjTsubo_Idle(ObjTsubo* this, PlayState* play) {
         ObjTsubo_SpawnCollectible(this, play);
         Actor_Kill(&this->actor);
     } else if ((this->collider.base.acFlags & AC_HIT) &&
-               (this->collider.info.acHitInfo->toucher.dmgFlags &
+               (this->collider.elem.acHitElem->toucher.dmgFlags &
                 (DMG_SWORD | DMG_RANGED | DMG_HAMMER | DMG_BOOMERANG | DMG_EXPLOSIVE))) {
         ObjTsubo_AirBreak(this, play);
         ObjTsubo_SpawnCollectible(this, play);
diff --git a/src/overlays/actors/ovl_player_actor/z_player.c b/src/overlays/actors/ovl_player_actor/z_player.c
index 22c14840f0..b9fce8f4e9 100644
--- a/src/overlays/actors/ovl_player_actor/z_player.c
+++ b/src/overlays/actors/ovl_player_actor/z_player.c
@@ -4007,12 +4007,12 @@ s32 func_80837818(Player* this) {
 }
 
 void func_80837918(Player* this, s32 quadIndex, u32 dmgFlags) {
-    this->meleeWeaponQuads[quadIndex].info.toucher.dmgFlags = dmgFlags;
+    this->meleeWeaponQuads[quadIndex].elem.toucher.dmgFlags = dmgFlags;
 
     if (dmgFlags == DMG_DEKU_STICK) {
-        this->meleeWeaponQuads[quadIndex].info.toucherFlags = TOUCH_ON | TOUCH_NEAREST | TOUCH_SFX_WOOD;
+        this->meleeWeaponQuads[quadIndex].elem.toucherFlags = TOUCH_ON | TOUCH_NEAREST | TOUCH_SFX_WOOD;
     } else {
-        this->meleeWeaponQuads[quadIndex].info.toucherFlags = TOUCH_ON | TOUCH_NEAREST;
+        this->meleeWeaponQuads[quadIndex].elem.toucherFlags = TOUCH_ON | TOUCH_NEAREST;
     }
 }
 
@@ -4361,7 +4361,7 @@ s32 func_808382DC(Player* this, PlayState* play) {
             // Additionally, `Collider.atHit` can never be set while already colliding as AC, so it's also bugged.
             // This behavior was later fixed in MM, most likely by removing both the `atHit` and `atFlags` checks.
             if (sp64 || ((this->invincibilityTimer < 0) && (this->cylinder.base.acFlags & AC_HIT) &&
-                         (this->cylinder.info.atHit != NULL) && (this->cylinder.info.atHit->atFlags & 0x20000000))) {
+                         (this->cylinder.elem.atHit != NULL) && (this->cylinder.elem.atHit->atFlags & 0x20000000))) {
 
                 Player_RequestRumble(this, 180, 20, 100, 0);
 
@@ -4394,7 +4394,7 @@ s32 func_808382DC(Player* this, PlayState* play) {
                     }
                 }
 
-                if (sp64 && (this->shieldQuad.info.acHitInfo->toucher.effect == 1)) {
+                if (sp64 && (this->shieldQuad.elem.acHitElem->toucher.effect == 1)) {
                     func_8083819C(this, play);
                 }