Sync Colliders Final (#1718)

* ElementDamageInfoAT

* ElementDamageInfoAC

* colMaterial

* elemMaterial

6 files changed, 208 insertions, 201 deletions

diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index aa3afcb98..6717639f3 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -4725,11 +4725,11 @@ void Actor_SetDropFlag(Actor* actor, ColliderElement* elem) {
 
     if (acHitElem == NULL) {
         actor->dropFlag = DROPFLAG_NONE;
-    } else if (acHitElem->toucher.dmgFlags & DMG_FIRE_ARROW) {
+    } else if (acHitElem->atDmgInfo.dmgFlags & DMG_FIRE_ARROW) {
         actor->dropFlag = DROPFLAG_1;
-    } else if (acHitElem->toucher.dmgFlags & DMG_ICE_ARROW) {
+    } else if (acHitElem->atDmgInfo.dmgFlags & DMG_ICE_ARROW) {
         actor->dropFlag = DROPFLAG_2;
-    } else if (acHitElem->toucher.dmgFlags & DMG_LIGHT_ARROW) {
+    } else if (acHitElem->atDmgInfo.dmgFlags & DMG_LIGHT_ARROW) {
         actor->dropFlag = DROPFLAG_20;
     } else {
         actor->dropFlag = DROPFLAG_NONE;
@@ -4751,7 +4751,7 @@ void Actor_SetDropFlagJntSph(Actor* actor, ColliderJntSph* jntSph) {
         if (acHitElem == NULL) {
             flag = DROPFLAG_NONE;
         } else {
-            s32 dmgFlags = acHitElem->toucher.dmgFlags;
+            s32 dmgFlags = acHitElem->atDmgInfo.dmgFlags;
 
             if (dmgFlags & DMG_FIRE_ARROW) {
                 flag = DROPFLAG_1;
@@ -4804,7 +4804,7 @@ void func_800BE3D0(Actor* actor, s16 angle, Vec3s* arg2) {
 
 void func_800BE504(Actor* actor, ColliderCylinder* cyl) {
     // Checks if was hit by either DMG_NORMAL_ARROW, DMG_FIRE_ARROW, DMG_ICE_ARROW, DMG_LIGHT_ARROW or DMG_DEKU_BUBBLE
-    if ((cyl->elem.acHitElem->toucher.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20))) {
+    if ((cyl->elem.acHitElem->atDmgInfo.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20))) {
         actor->world.rot.y = cyl->base.ac->shape.rot.y;
     } else {
         actor->world.rot.y = Actor_WorldYawTowardActor(cyl->base.ac, actor);
@@ -4812,7 +4812,7 @@ void func_800BE504(Actor* actor, ColliderCylinder* cyl) {
 }
 
 void func_800BE568(Actor* actor, ColliderSphere* sph) {
-    if (sph->elem.acHitElem->toucher.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20)) {
+    if (sph->elem.acHitElem->atDmgInfo.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20)) {
         actor->world.rot.y = sph->base.ac->shape.rot.y;
     } else {
         actor->world.rot.y = Actor_WorldYawTowardActor(sph->base.ac, actor);
@@ -4820,7 +4820,7 @@ void func_800BE568(Actor* actor, ColliderSphere* sph) {
 }
 
 void func_800BE5CC(Actor* actor, ColliderJntSph* jntSph, s32 elemIndex) {
-    if (jntSph->elements[elemIndex].base.acHitElem->toucher.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20)) {
+    if (jntSph->elements[elemIndex].base.acHitElem->atDmgInfo.dmgFlags & (0x10000 | 0x2000 | 0x1000 | 0x800 | 0x20)) {
         actor->world.rot.y = jntSph->base.ac->shape.rot.y;
     } else {
         actor->world.rot.y = Actor_WorldYawTowardActor(jntSph->base.ac, actor);
diff --git a/src/code/z_collision_check.c b/src/code/z_collision_check.c
index 75e3a11a2..5cf01a80e 100644
--- a/src/code/z_collision_check.c
+++ b/src/code/z_collision_check.c
@@ -109,8 +109,8 @@ TriNorm D_801EE188;
  * Gets the damage and effect that should be applied for the collision between
  * `at` and `ac`, referring to the ac actor's damage chart if applicable.
  */
-f32 CollisionCheck_GetDamageAndEffectOnBumper(Collider* atCol, ColliderElement* atElem, Collider* acCol,
-                                              ColliderElement* acElem, u32* effect) {
+f32 CollisionCheck_GetDamageAndEffectOnElementAC(Collider* atCol, ColliderElement* atElem, Collider* acCol,
+                                                 ColliderElement* acElem, u32* effect) {
     static f32 sDamageMultipliers[] = {
         0.0f, 1.0f, 2.0f, 0.5f, 0.25f, 3.0f, 4.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
     };
@@ -119,10 +119,10 @@ f32 CollisionCheck_GetDamageAndEffectOnBumper(Collider* atCol, ColliderElement*
     f32 damage;
 
     *effect = 0;
-    damage = CollisionCheck_GetToucherDamage(atCol, atElem, acCol, acElem);
+    damage = CollisionCheck_GetElementATDamage(atCol, atElem, acCol, acElem);
 
     if (acCol->actor->colChkInfo.damageTable != NULL) {
-        dmgFlags = atElem->toucher.dmgFlags;
+        dmgFlags = atElem->atDmgInfo.dmgFlags;
 
         for (i = 0; i < ARRAY_COUNT(acCol->actor->colChkInfo.damageTable->attack); i++) {
             if (dmgFlags == 1) {
@@ -140,8 +140,8 @@ f32 CollisionCheck_GetDamageAndEffectOnBumper(Collider* atCol, ColliderElement*
 /**
  * Calculates damage after factoring in the ac collider's defense
  */
-f32 CollisionCheck_ApplyBumperDefense(f32 damage, ColliderElement* acElem) {
-    f32 finalDamage = damage - acElem->bumper.defense;
+f32 CollisionCheck_ApplyElementATDefense(f32 damage, ColliderElement* acElem) {
+    f32 finalDamage = damage - acElem->acDmgInfo.defense;
 
     return finalDamage;
 }
@@ -150,18 +150,18 @@ f32 CollisionCheck_ApplyBumperDefense(f32 damage, ColliderElement* acElem) {
  * Gets the damage to be inflicted by `at` on `ac`, before applying other
  * factors such as the ac collider's defense.
  */
-s32 CollisionCheck_GetToucherDamage(Collider* atCol, ColliderElement* atElem, Collider* acCol,
-                                    ColliderElement* acElem) {
+s32 CollisionCheck_GetElementATDamage(Collider* atCol, ColliderElement* atElem, Collider* acCol,
+                                      ColliderElement* acElem) {
     if ((atCol->actor != NULL) && (atCol->actor->id == ACTOR_EN_BOM) && (acCol->actor != NULL) &&
         (acCol->actor->id == ACTOR_PLAYER)) {
         return 8;
     }
-    return atElem->toucher.damage;
+    return atElem->atDmgInfo.damage;
 }
 
 s32 Collider_InitBase(struct PlayState* play, Collider* col) {
     static Collider sDefaultCollider = {
-        NULL, NULL, NULL, NULL, AT_NONE, AC_NONE, OC1_NONE, OC2_NONE, COLTYPE_HIT3, COLSHAPE_MAX,
+        NULL, NULL, NULL, NULL, AT_NONE, AC_NONE, OC1_NONE, OC2_NONE, COL_MATERIAL_HIT3, COLSHAPE_MAX,
     };
 
     *col = sDefaultCollider;
@@ -173,7 +173,7 @@ s32 Collider_DestroyBase(struct PlayState* play, Collider* col) {
 }
 
 /**
- * Uses default OC2_TYPE_1 and COLTYPE_HIT0
+ * Uses default OC2_TYPE_1 and COL_MATERIAL_HIT0
  */
 s32 Collider_SetBaseToActor(struct PlayState* play, Collider* col, ColliderInitToActor* src) {
     col->actor = src->actor;
@@ -190,7 +190,7 @@ s32 Collider_SetBaseToActor(struct PlayState* play, Collider* col, ColliderInitT
  */
 s32 Collider_SetBaseType1(struct PlayState* play, Collider* col, Actor* actor, ColliderInitType1* src) {
     col->actor = actor;
-    col->colType = src->colType;
+    col->colMaterial = src->colMaterial;
     col->atFlags = src->atFlags;
     col->acFlags = src->acFlags;
     col->ocFlags1 = src->ocFlags1;
@@ -201,7 +201,7 @@ s32 Collider_SetBaseType1(struct PlayState* play, Collider* col, Actor* actor, C
 
 s32 Collider_SetBase(struct PlayState* play, Collider* col, Actor* actor, ColliderInit* src) {
     col->actor = actor;
-    col->colType = src->colType;
+    col->colMaterial = src->colMaterial;
     col->atFlags = src->atFlags;
     col->acFlags = src->acFlags;
     col->ocFlags1 = src->ocFlags1;
@@ -226,72 +226,79 @@ void Collider_ResetOCBase(struct PlayState* play, Collider* col) {
     col->ocFlags2 &= ~OC2_HIT_PLAYER;
 }
 
-s32 Collider_InitTouch(struct PlayState* play, ColliderTouch* touch) {
-    static ColliderTouch sDefaultColliderTouch = { 0x00000000, 0, 0 };
+s32 Collider_InitElementDamageInfoAT(struct PlayState* play, ColliderElementDamageInfoAT* atDmgInfo) {
+    static ColliderElementDamageInfoAT sDefaultDamageInfoAT = { 0x00000000, 0, 0 };
 
-    *touch = sDefaultColliderTouch;
+    *atDmgInfo = sDefaultDamageInfoAT;
     return 1;
 }
 
-s32 Collider_DestroyTouch(struct PlayState* play, ColliderTouch* touch) {
+s32 Collider_DestroyElementDamageInfoAT(struct PlayState* play, ColliderElementDamageInfoAT* atDmgInfo) {
     return 1;
 }
 
-s32 Collider_SetTouch(struct PlayState* play, ColliderTouch* touch, ColliderTouchInit* src) {
-    touch->dmgFlags = src->dmgFlags;
-    touch->effect = src->effect;
-    touch->damage = src->damage;
+s32 Collider_SetElementDamageInfoAT(struct PlayState* play, ColliderElementDamageInfoAT* dest,
+                                    ColliderElementDamageInfoATInit* src) {
+    dest->dmgFlags = src->dmgFlags;
+    dest->effect = src->effect;
+    dest->damage = src->damage;
     return 1;
 }
 
 void Collider_ResetATElementUnk(struct PlayState* play, ColliderElement* elem) {
 }
 
-s32 Collider_InitBump(struct PlayState* play, ColliderBump* bump) {
-    static ColliderBump sDefaultColliderBump = { 0xF7CFFFFF, 0, 0, { 0, 0, 0 } };
+s32 Collider_InitElementDamageInfoAC(struct PlayState* play, ColliderElementDamageInfoAC* acDmgInfo) {
+    static ColliderElementDamageInfoAC sDefaultDamageInfoAC = { 0xF7CFFFFF, 0, 0, { 0, 0, 0 } };
 
-    *bump = sDefaultColliderBump;
+    *acDmgInfo = sDefaultDamageInfoAC;
     return 1;
 }
 
-s32 Collider_DestroyBump(struct PlayState* play, ColliderBump* bump) {
+s32 Collider_DestroyElementDamageInfoAC(struct PlayState* play, ColliderElementDamageInfoAC* acDmgInfo) {
     return 1;
 }
 
-s32 Collider_SetBump(struct PlayState* play, ColliderBump* bump, ColliderBumpInit* src) {
-    bump->dmgFlags = src->dmgFlags;
-    bump->effect = src->effect;
-    bump->defense = src->defense;
+s32 Collider_SetElementDamageInfoAC(struct PlayState* play, ColliderElementDamageInfoAC* dest,
+                                    ColliderElementDamageInfoACInit* src) {
+    dest->dmgFlags = src->dmgFlags;
+    dest->effect = src->effect;
+    dest->defense = src->defense;
     return 1;
 }
 
 s32 Collider_InitElement(struct PlayState* play, ColliderElement* elem) {
     static ColliderElement sDefaultColliderElement = {
-        { 0, 0, 0 },   { 0xF7CFFFFF, 0, 0, { 0, 0, 0 } },
-        ELEMTYPE_UNK0, TOUCH_NONE,
-        BUMP_NONE,     OCELEM_NONE,
-        NULL,          NULL,
-        NULL,          NULL,
+        { 0, 0, 0 },
+        { 0xF7CFFFFF, 0, 0, { 0, 0, 0 } },
+        ELEM_MATERIAL_UNK0,
+        ATELEM_NONE,
+        ACELEM_NONE,
+        OCELEM_NONE,
+        NULL,
+        NULL,
+        NULL,
+        NULL,
     };
 
     *elem = sDefaultColliderElement;
-    Collider_InitTouch(play, &elem->toucher);
-    Collider_InitBump(play, &elem->bumper);
+    Collider_InitElementDamageInfoAT(play, &elem->atDmgInfo);
+    Collider_InitElementDamageInfoAC(play, &elem->acDmgInfo);
     return 1;
 }
 
 s32 Collider_DestroyElement(struct PlayState* play, ColliderElement* elem) {
-    Collider_DestroyTouch(play, &elem->toucher);
-    Collider_DestroyBump(play, &elem->bumper);
+    Collider_DestroyElementDamageInfoAT(play, &elem->atDmgInfo);
+    Collider_DestroyElementDamageInfoAC(play, &elem->acDmgInfo);
     return 1;
 }
 
 s32 Collider_SetElement(struct PlayState* play, ColliderElement* elem, ColliderElementInit* elemInit) {
-    elem->elemType = elemInit->elemType;
-    Collider_SetTouch(play, &elem->toucher, &elemInit->toucher);
-    Collider_SetBump(play, &elem->bumper, &elemInit->bumper);
-    elem->toucherFlags = elemInit->toucherFlags;
-    elem->bumperFlags = elemInit->bumperFlags;
+    elem->elemMaterial = elemInit->elemMaterial;
+    Collider_SetElementDamageInfoAT(play, &elem->atDmgInfo, &elemInit->atDmgInfo);
+    Collider_SetElementDamageInfoAC(play, &elem->acDmgInfo, &elemInit->acDmgInfo);
+    elem->atElemFlags = elemInit->atElemFlags;
+    elem->acElemFlags = elemInit->acElemFlags;
     elem->ocElemFlags = elemInit->ocElemFlags;
     return 1;
 }
@@ -299,15 +306,15 @@ s32 Collider_SetElement(struct PlayState* play, ColliderElement* elem, ColliderE
 void Collider_ResetATElement(struct PlayState* play, ColliderElement* elem) {
     elem->atHit = NULL;
     elem->atHitElem = NULL;
-    elem->toucherFlags &= ~TOUCH_HIT;
-    elem->toucherFlags &= ~TOUCH_DREW_HITMARK;
+    elem->atElemFlags &= ~ATELEM_HIT;
+    elem->atElemFlags &= ~ATELEM_DREW_HITMARK;
     Collider_ResetATElementUnk(play, elem);
 }
 
 void Collider_ResetACElement(struct 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->acDmgInfo.hitPos.x = elem->acDmgInfo.hitPos.y = elem->acDmgInfo.hitPos.z = 0;
+    elem->acElemFlags &= ~ACELEM_HIT;
+    elem->acElemFlags &= ~ACELEM_DRAW_HITMARK;
     elem->acHit = NULL;
     elem->acHitElem = NULL;
 }
@@ -420,7 +427,7 @@ s32 Collider_DestroyJntSph(struct PlayState* play, ColliderJntSph* jntSph) {
 
 /**
  * Sets up the ColliderJntSph using the values in src, sets it to the actor specified in src, and dynamically allocates
- * the element array. Uses default OC2_TYPE_1 and COLTYPE_HIT0.
+ * the element array. Uses default OC2_TYPE_1 and COL_MATERIAL_HIT0.
  */
 s32 Collider_SetJntSphToActor(struct PlayState* play, ColliderJntSph* dest, ColliderJntSphInitToActor* src) {
     ColliderJntSphElement* destElem;
@@ -583,7 +590,7 @@ s32 Collider_DestroyCylinder(struct PlayState* play, ColliderCylinder* cyl) {
 
 /**
  * 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.
+ * OC2_TYPE_1 and COL_MATERIAL_0.
  */
 s32 Collider_SetCylinderToActor(struct PlayState* play, ColliderCylinder* dest, ColliderCylinderInitToActor* src) {
     Collider_SetBaseToActor(play, &dest->base, &src->base);
@@ -997,14 +1004,14 @@ s32 Collider_ResetQuadOC(struct PlayState* play, Collider* col) {
 }
 
 /**
- * For quad colliders with TOUCH_NEAREST, resets the previous AC collider it hit if the current element is closer,
+ * For quad colliders with ATELEM_NEAREST, resets the previous AC collider it hit if the current element is closer,
  * otherwise returns false. Used on player AT colliders to prevent multiple collisions from registering.
  */
 s32 Collider_QuadSetNearestAC(struct PlayState* play, ColliderQuad* quad, Vec3f* hitPos) {
     f32 acDist;
     Vec3f dcMid;
 
-    if (!(quad->elem.toucherFlags & TOUCH_NEAREST)) {
+    if (!(quad->elem.atElemFlags & ATELEM_NEAREST)) {
         return 1;
     }
     Math_Vec3s_ToVec3f(&dcMid, &quad->dim.dcMid);
@@ -1419,28 +1426,28 @@ s32 CollisionCheck_SetOCLine(struct PlayState* play, CollisionCheckContext* colC
 /**
  * Skips AT elements that are off.
  */
-s32 CollisionCheck_SkipTouch(ColliderElement* elem) {
-    if (!(elem->toucherFlags & TOUCH_ON)) {
-        return 1;
+s32 CollisionCheck_IsElementNotAT(ColliderElement* elem) {
+    if (!(elem->atElemFlags & ATELEM_ON)) {
+        return true;
     }
-    return 0;
+    return false;
 }
 
 /**
  * Skips AC elements that are off.
  */
-s32 CollisionCheck_SkipBump(ColliderElement* elem) {
-    if (!(elem->bumperFlags & BUMP_ON)) {
-        return 1;
+s32 CollisionCheck_IsElementNotAC(ColliderElement* elem) {
+    if (!(elem->acElemFlags & ACELEM_ON)) {
+        return true;
     }
-    return 0;
+    return false;
 }
 
 /**
  * If the AT element has no dmgFlags in common with the AC element, no collision happens.
  */
 s32 CollisionCheck_NoSharedFlags(ColliderElement* atElem, ColliderElement* acElem) {
-    if (!(atElem->toucher.dmgFlags & acElem->bumper.dmgFlags)) {
+    if (!(atElem->atDmgInfo.dmgFlags & acElem->acDmgInfo.dmgFlags)) {
         return true;
     }
     return false;
@@ -1589,30 +1596,30 @@ void CollisionCheck_RedBloodUnused(struct PlayState* play, Collider* col, Vec3f*
  * Plays sound effects and displays hitmarks for solid-type AC colliders (METAL, WOOD, HARD, and TREE)
  */
 void CollisionCheck_HitSolid(struct PlayState* play, ColliderElement* elem, Collider* col, Vec3f* hitPos) {
-    s32 flags = elem->toucherFlags & TOUCH_SFX_NONE;
+    s32 flags = elem->atElemFlags & ATELEM_SFX_NONE;
 
-    if ((flags == TOUCH_SFX_NORMAL) && (col->colType != COLTYPE_METAL)) {
+    if ((flags == ATELEM_SFX_NORMAL) && (col->colMaterial != COL_MATERIAL_METAL)) {
         EffectSsHitmark_SpawnFixedScale(play, 0, hitPos);
         if (col->actor == NULL) {
             Audio_PlaySfx(NA_SE_IT_SHIELD_BOUND);
         } else {
             Audio_PlaySfx_AtPos(&col->actor->projectedPos, NA_SE_IT_SHIELD_BOUND);
         }
-    } else if (flags == TOUCH_SFX_NORMAL) {
+    } else if (flags == ATELEM_SFX_NORMAL) {
         EffectSsHitmark_SpawnFixedScale(play, 3, hitPos);
         if (col->actor == NULL) {
             CollisionCheck_SpawnShieldParticlesMetal(play, hitPos);
         } else {
             CollisionCheck_SpawnShieldParticlesMetalSound(play, hitPos, &col->actor->projectedPos);
         }
-    } else if (flags == TOUCH_SFX_HARD) {
+    } else if (flags == ATELEM_SFX_HARD) {
         EffectSsHitmark_SpawnFixedScale(play, 0, hitPos);
         if (col->actor == NULL) {
             Audio_PlaySfx(NA_SE_IT_SHIELD_BOUND);
         } else {
             Audio_PlaySfx_AtPos(&col->actor->projectedPos, NA_SE_IT_SHIELD_BOUND);
         }
-    } else if (flags == TOUCH_SFX_WOOD) {
+    } else if (flags == ATELEM_SFX_WOOD) {
         EffectSsHitmark_SpawnFixedScale(play, 1, hitPos);
         if (col->actor == NULL) {
             Audio_PlaySfx(NA_SE_IT_REFLECTION_WOOD);
@@ -1623,17 +1630,17 @@ void CollisionCheck_HitSolid(struct PlayState* play, ColliderElement* elem, Coll
 }
 
 /**
- * Plays a hit sound effect for AT colliders attached to Player based on the AC element's elemType.
+ * Plays a hit sound effect for AT colliders attached to Player based on the AC element's elemMaterial.
  */
 s32 CollisionCheck_SwordHitAudio(Collider* at, ColliderElement* acElem) {
     if ((at->actor != NULL) && (at->actor->category == ACTORCAT_PLAYER)) {
-        if (acElem->elemType == ELEMTYPE_UNK0) {
+        if (acElem->elemMaterial == ELEM_MATERIAL_UNK0) {
             Audio_PlaySfx_AtPos(&at->actor->projectedPos, NA_SE_IT_SWORD_STRIKE);
-        } else if (acElem->elemType == ELEMTYPE_UNK1) {
+        } else if (acElem->elemMaterial == ELEM_MATERIAL_UNK1) {
             Audio_PlaySfx_AtPos(&at->actor->projectedPos, NA_SE_IT_SWORD_STRIKE_HARD);
-        } else if (acElem->elemType == ELEMTYPE_UNK2) {
+        } else if (acElem->elemMaterial == ELEM_MATERIAL_UNK2) {
             Audio_PlaySfx_AtPos(&at->actor->projectedPos, 0);
-        } else if (acElem->elemType == ELEMTYPE_UNK3) {
+        } else if (acElem->elemMaterial == ELEM_MATERIAL_UNK3) {
             Audio_PlaySfx_AtPos(&at->actor->projectedPos, 0);
         }
     }
@@ -1653,34 +1660,34 @@ HitInfo sHitInfo[] = {
 };
 
 /**
- * Handles hitmarks, blood, and sound effects for each AC collision, determined by the AC collider's colType
+ * Handles hitmarks, blood, and sound effects for each AC collision, determined by the AC collider's colMaterial
  */
 void CollisionCheck_HitEffects(struct PlayState* play, Collider* at, ColliderElement* atElem, Collider* ac,
                                ColliderElement* acElem, Vec3f* hitPos) {
-    if (acElem->bumperFlags & BUMP_NO_HITMARK) {
+    if (acElem->acElemFlags & ACELEM_NO_HITMARK) {
         return;
     }
 
-    if (!(atElem->toucherFlags & TOUCH_AT_HITMARK) && (atElem->toucherFlags & TOUCH_DREW_HITMARK)) {
+    if (!(atElem->atElemFlags & ATELEM_AT_HITMARK) && (atElem->atElemFlags & ATELEM_DREW_HITMARK)) {
         return;
     }
 
     if (ac->actor != NULL) {
-        sBloodFuncs[sHitInfo[ac->colType].blood](play, ac, hitPos);
+        sBloodFuncs[sHitInfo[ac->colMaterial].blood](play, ac, hitPos);
     }
     if (ac->actor != NULL) {
-        if (sHitInfo[ac->colType].effect == HIT_SOLID) {
+        if (sHitInfo[ac->colMaterial].effect == HIT_SOLID) {
             CollisionCheck_HitSolid(play, atElem, ac, hitPos);
-        } else if (sHitInfo[ac->colType].effect == HIT_WOOD) {
+        } else if (sHitInfo[ac->colMaterial].effect == HIT_WOOD) {
             if (at->actor == NULL) {
                 CollisionCheck_SpawnShieldParticles(play, hitPos);
                 Audio_PlaySfx(NA_SE_IT_REFLECTION_WOOD);
             } else {
                 CollisionCheck_SpawnShieldParticlesWood(play, hitPos, &at->actor->projectedPos);
             }
-        } else if (sHitInfo[ac->colType].effect != HIT_NONE) {
-            EffectSsHitmark_SpawnFixedScale(play, sHitInfo[ac->colType].effect, hitPos);
-            if (!(acElem->bumperFlags & BUMP_NO_SWORD_SFX)) {
+        } else if (sHitInfo[ac->colMaterial].effect != HIT_NONE) {
+            EffectSsHitmark_SpawnFixedScale(play, sHitInfo[ac->colMaterial].effect, hitPos);
+            if (!(acElem->acElemFlags & ACELEM_NO_SWORD_SFX)) {
                 CollisionCheck_SwordHitAudio(at, acElem);
             }
         }
@@ -1710,32 +1717,32 @@ s32 CollisionCheck_SetATvsAC(struct PlayState* play, Collider* atCol, ColliderEl
     f32 damage;
     u32 effect;
 
-    if (CollisionCheck_GetToucherDamage(atCol, atElem, acCol, acElem) != 0) {
-        damage = CollisionCheck_GetDamageAndEffectOnBumper(atCol, atElem, acCol, acElem, &effect);
+    if (CollisionCheck_GetElementATDamage(atCol, atElem, acCol, acElem) != 0) {
+        damage = CollisionCheck_GetDamageAndEffectOnElementAC(atCol, atElem, acCol, acElem, &effect);
         if (damage < 1.0f) {
             if (effect == 0) {
                 return 0;
             }
-        } else if ((CollisionCheck_ApplyBumperDefense(damage, acElem) < 1.0f) && (effect == 0)) {
+        } else if ((CollisionCheck_ApplyElementATDefense(damage, acElem) < 1.0f) && (effect == 0)) {
             return 0;
         }
     }
     if ((acCol->acFlags & AC_HARD) && (atCol->actor != NULL) && (acCol->actor != NULL)) {
         CollisionCheck_SetBounce(atCol, acCol);
     }
-    if (!(acElem->bumperFlags & BUMP_NO_AT_INFO)) {
+    if (!(acElem->acElemFlags & ACELEM_NO_AT_INFO)) {
         atCol->atFlags |= AT_HIT;
         atCol->at = acCol->actor;
         atElem->atHit = acCol;
-        atElem->toucherFlags |= TOUCH_HIT;
+        atElem->atElemFlags |= ATELEM_HIT;
         atElem->atHitElem = acElem;
-        if (!(atElem->bumperFlags & BUMP_HIT)) {
-            atElem->bumper.hitPos.x = hitPos->x;
-            atElem->bumper.hitPos.y = hitPos->y;
-            atElem->bumper.hitPos.z = hitPos->z;
+        if (!(atElem->acElemFlags & ACELEM_HIT)) {
+            atElem->acDmgInfo.hitPos.x = hitPos->x;
+            atElem->acDmgInfo.hitPos.y = hitPos->y;
+            atElem->acDmgInfo.hitPos.z = hitPos->z;
         }
         if (atCol->actor != NULL) {
-            atCol->actor->colChkInfo.atHitEffect = acElem->bumper.effect;
+            atCol->actor->colChkInfo.atHitEffect = acElem->acDmgInfo.effect;
         }
     }
     if (!(atElem->ocElemFlags & OCELEM_UNK2)) {
@@ -1743,20 +1750,20 @@ s32 CollisionCheck_SetATvsAC(struct PlayState* play, Collider* atCol, ColliderEl
         acCol->ac = atCol->actor;
         acElem->acHit = atCol;
         acElem->acHitElem = atElem;
-        acElem->bumperFlags |= BUMP_HIT;
+        acElem->acElemFlags |= ACELEM_HIT;
         if (acCol->actor != NULL) {
-            acCol->actor->colChkInfo.acHitEffect = atElem->toucher.effect;
+            acCol->actor->colChkInfo.acHitEffect = atElem->atDmgInfo.effect;
         }
-        acElem->bumper.hitPos.x = hitPos->x;
-        acElem->bumper.hitPos.y = hitPos->y;
-        acElem->bumper.hitPos.z = hitPos->z;
+        acElem->acDmgInfo.hitPos.x = hitPos->x;
+        acElem->acDmgInfo.hitPos.y = hitPos->y;
+        acElem->acDmgInfo.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;
+    if (!(atElem->atElemFlags & ATELEM_AT_HITMARK) && (acCol->colMaterial != COL_MATERIAL_METAL) &&
+        (acCol->colMaterial != COL_MATERIAL_WOOD) && (acCol->colMaterial != COL_MATERIAL_HARD)) {
+        acElem->acElemFlags |= ACELEM_DRAW_HITMARK;
     } else {
         CollisionCheck_HitEffects(play, atCol, atElem, acCol, acElem, hitPos);
-        atElem->toucherFlags |= TOUCH_DREW_HITMARK;
+        atElem->atElemFlags |= ATELEM_DREW_HITMARK;
     }
     return 1;
 }
@@ -1793,13 +1800,13 @@ void CollisionCheck_AC_JntSphVsJntSph(struct PlayState* play, CollisionCheckCont
     if ((atJntSph->count > 0) && (atJntSph->elements != NULL) && (acJntSph->count > 0) &&
         (acJntSph->elements != NULL)) {
         for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
-            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base)) {
                 continue;
             }
 
             for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count];
                  acJntSphElem++) {
-                if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
+                if (CollisionCheck_IsElementNotAC(&acJntSphElem->base)) {
                     continue;
                 }
                 if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acJntSphElem->base)) {
@@ -1848,11 +1855,11 @@ void CollisionCheck_AC_JntSphVsCyl(struct PlayState* play, CollisionCheckContext
     f32 centerDist;
 
     if ((atJntSph->count > 0) && (atJntSph->elements != NULL) && (acCyl->dim.radius > 0) && (acCyl->dim.height > 0)) {
-        if (CollisionCheck_SkipBump(&acCyl->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acCyl->elem)) {
             return;
         }
         for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
-            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acCyl->elem)) {
@@ -1900,11 +1907,11 @@ void CollisionCheck_AC_JntSphVsTris(struct PlayState* play, CollisionCheckContex
 
     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_SkipTouch(&atJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base)) {
                 continue;
             }
             for (acTrisElem = acTris->elements; acTrisElem < &acTris->elements[acTris->count]; acTrisElem++) {
-                if (CollisionCheck_SkipBump(&acTrisElem->base)) {
+                if (CollisionCheck_IsElementNotAC(&acTrisElem->base)) {
                     continue;
                 }
                 if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acTrisElem->base)) {
@@ -1936,14 +1943,14 @@ void CollisionCheck_AC_JntSphVsQuad(struct PlayState* play, CollisionCheckContex
     ColliderJntSphElement* atJntSphElem;
 
     if ((atJntSph->count > 0) && (atJntSph->elements != NULL)) {
-        if (CollisionCheck_SkipBump(&acQuad->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acQuad->elem)) {
             return;
         }
         Math3D_TriNorm(&D_801EF590, &acQuad->dim.quad[2], &acQuad->dim.quad[3], &acQuad->dim.quad[1]);
         Math3D_TriNorm(&D_801EF5C8, &acQuad->dim.quad[1], &acQuad->dim.quad[0], &acQuad->dim.quad[2]);
 
         for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
-            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acQuad->elem)) {
@@ -1976,11 +1983,11 @@ void CollisionCheck_AC_JntSphVsSphere(struct PlayState* play, CollisionCheckCont
     f32 centerDist;
 
     if ((atJntSph->count > 0) && (atJntSph->elements != NULL)) {
-        if (CollisionCheck_SkipBump(&acSph->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acSph->elem)) {
             return;
         }
         for (atJntSphElem = atJntSph->elements; atJntSphElem < &atJntSph->elements[atJntSph->count]; atJntSphElem++) {
-            if (CollisionCheck_SkipTouch(&atJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acSph->elem)) {
@@ -2022,11 +2029,11 @@ void CollisionCheck_AC_CylVsJntSph(struct PlayState* play, CollisionCheckContext
     ColliderJntSphElement* acJntSphElem;
 
     if ((acJntSph->count > 0) && (acJntSph->elements != NULL) && (atCyl->dim.radius > 0) && (atCyl->dim.height > 0)) {
-        if (CollisionCheck_SkipTouch(&atCyl->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem)) {
             return;
         }
         for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count]; acJntSphElem++) {
-            if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAC(&acJntSphElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acJntSphElem->base)) {
@@ -2074,10 +2081,10 @@ void CollisionCheck_AC_CylVsCyl(struct PlayState* play, CollisionCheckContext* c
     f32 centerDist;
 
     if ((atCyl->dim.radius > 0) && (atCyl->dim.height > 0) && (acCyl->dim.radius > 0) && (acCyl->dim.height > 0)) {
-        if (CollisionCheck_SkipBump(&acCyl->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acCyl->elem)) {
             return;
         }
-        if (CollisionCheck_SkipTouch(&atCyl->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem)) {
             return;
         }
         if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acCyl->elem)) {
@@ -2128,12 +2135,12 @@ void CollisionCheck_AC_CylVsTris(struct PlayState* play, CollisionCheckContext*
     Vec3f hitPos;
 
     if ((atCyl->dim.radius > 0) && (atCyl->dim.height > 0) && (acTris->count > 0) && (acTris->elements != NULL)) {
-        if (CollisionCheck_SkipTouch(&atCyl->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem)) {
             return;
         }
 
         for (acTrisElem = acTris->elements; acTrisElem < &acTris->elements[acTris->count]; acTrisElem++) {
-            if (CollisionCheck_SkipBump(&acTrisElem->base)) {
+            if (CollisionCheck_IsElementNotAC(&acTrisElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acTrisElem->base)) {
@@ -2163,10 +2170,10 @@ void CollisionCheck_AC_CylVsQuad(struct PlayState* play, CollisionCheckContext*
     ColliderQuad* acQuad = (ColliderQuad*)acCol;
 
     if ((atCyl->dim.height > 0) && (atCyl->dim.radius > 0)) {
-        if (CollisionCheck_SkipTouch(&atCyl->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem)) {
             return;
         }
-        if (CollisionCheck_SkipBump(&acQuad->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acQuad->elem)) {
             return;
         }
         if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acQuad->elem)) {
@@ -2206,10 +2213,10 @@ void CollisionCheck_AC_CylVsSphere(struct PlayState* play, CollisionCheckContext
     f32 centerDist;
 
     if ((atCyl->dim.radius > 0) && (atCyl->dim.height > 0)) {
-        if (CollisionCheck_SkipTouch(&atCyl->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem)) {
             return;
         }
-        if (CollisionCheck_SkipBump(&acSph->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acSph->elem)) {
             return;
         }
         if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acSph->elem)) {
@@ -2256,11 +2263,11 @@ void CollisionCheck_AC_TrisVsJntSph(struct PlayState* play, CollisionCheckContex
 
     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_SkipBump(&acJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAC(&acJntSphElem->base)) {
                 continue;
             }
             for (atTrisElem = atTris->elements; atTrisElem < &atTris->elements[atTris->count]; atTrisElem++) {
-                if (CollisionCheck_SkipTouch(&atTrisElem->base)) {
+                if (CollisionCheck_IsElementNotAT(&atTrisElem->base)) {
                     continue;
                 }
                 if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acJntSphElem->base)) {
@@ -2294,11 +2301,11 @@ void CollisionCheck_AC_TrisVsCyl(struct PlayState* play, CollisionCheckContext*
     ColliderTrisElement* atTrisElem;
 
     if ((acCyl->dim.radius > 0) && (acCyl->dim.height > 0) && (atTris->count > 0) && (atTris->elements != NULL)) {
-        if (CollisionCheck_SkipBump(&acCyl->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acCyl->elem)) {
             return;
         }
         for (atTrisElem = atTris->elements; atTrisElem < &atTris->elements[atTris->count]; atTrisElem++) {
-            if (CollisionCheck_SkipTouch(&atTrisElem->base)) {
+            if (CollisionCheck_IsElementNotAT(&atTrisElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acCyl->elem)) {
@@ -2330,11 +2337,11 @@ void CollisionCheck_AC_TrisVsTris(struct PlayState* play, CollisionCheckContext*
 
     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_SkipBump(&acTrisElem->base)) {
+            if (CollisionCheck_IsElementNotAC(&acTrisElem->base)) {
                 continue;
             }
             for (atTrisElem = atTris->elements; atTrisElem < &atTris->elements[atTris->count]; atTrisElem++) {
-                if (CollisionCheck_SkipTouch(&atTrisElem->base)) {
+                if (CollisionCheck_IsElementNotAT(&atTrisElem->base)) {
                     continue;
                 }
                 if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acTrisElem->base)) {
@@ -2365,7 +2372,7 @@ void CollisionCheck_AC_TrisVsQuad(struct PlayState* play, CollisionCheckContext*
     ColliderTrisElement* atTrisElem;
 
     if ((atTris->count > 0) && (atTris->elements != NULL)) {
-        if (CollisionCheck_SkipBump(&acQuad->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acQuad->elem)) {
             return;
         }
 
@@ -2373,7 +2380,7 @@ void CollisionCheck_AC_TrisVsQuad(struct PlayState* play, CollisionCheckContext*
         Math3D_TriNorm(&D_801EDE78, &acQuad->dim.quad[1], &acQuad->dim.quad[0], &acQuad->dim.quad[2]);
 
         for (atTrisElem = atTris->elements; atTrisElem < &atTris->elements[atTris->count]; atTrisElem++) {
-            if (CollisionCheck_SkipTouch(&atTrisElem->base)) {
+            if (CollisionCheck_IsElementNotAT(&atTrisElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acQuad->elem)) {
@@ -2405,11 +2412,11 @@ void CollisionCheck_AC_TrisVsSphere(struct PlayState* play, CollisionCheckContex
     Vec3f hitPos;
 
     if ((atTris->count > 0) && (atTris->elements != NULL)) {
-        if (CollisionCheck_SkipBump(&acSph->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acSph->elem)) {
             return;
         }
         for (atTrisElem = atTris->elements; atTrisElem < &atTris->elements[atTris->count]; atTrisElem++) {
-            if (CollisionCheck_SkipTouch(&atTrisElem->base)) {
+            if (CollisionCheck_IsElementNotAT(&atTrisElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acSph->elem)) {
@@ -2439,14 +2446,14 @@ void CollisionCheck_AC_QuadVsJntSph(struct PlayState* play, CollisionCheckContex
     ColliderJntSph* acJntSph = (ColliderJntSph*)acCol;
 
     if ((acJntSph->count > 0) && (acJntSph->elements != NULL)) {
-        if (CollisionCheck_SkipTouch(&atQuad->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atQuad->elem)) {
             return;
         }
         Math3D_TriNorm(&D_801EDEC8, &atQuad->dim.quad[2], &atQuad->dim.quad[3], &atQuad->dim.quad[1]);
         Math3D_TriNorm(&D_801EDF00, &atQuad->dim.quad[2], &atQuad->dim.quad[1], &atQuad->dim.quad[0]);
 
         for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count]; acJntSphElem++) {
-            if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAC(&acJntSphElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acJntSphElem->base)) {
@@ -2482,10 +2489,10 @@ void CollisionCheck_AC_QuadVsCyl(struct PlayState* play, CollisionCheckContext*
     ColliderCylinder* acCyl = (ColliderCylinder*)acCol;
 
     if ((acCyl->dim.height > 0) && (acCyl->dim.radius > 0)) {
-        if (CollisionCheck_SkipBump(&acCyl->elem)) {
+        if (CollisionCheck_IsElementNotAC(&acCyl->elem)) {
             return;
         }
-        if (CollisionCheck_SkipTouch(&atQuad->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atQuad->elem)) {
             return;
         }
         if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acCyl->elem)) {
@@ -2531,7 +2538,7 @@ void CollisionCheck_AC_QuadVsTris(struct PlayState* play, CollisionCheckContext*
     ColliderTrisElement* acTrisElem;
 
     if ((acTris->count > 0) && (acTris->elements != NULL)) {
-        if (CollisionCheck_SkipTouch(&atQuad->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atQuad->elem)) {
             return;
         }
 
@@ -2539,7 +2546,7 @@ void CollisionCheck_AC_QuadVsTris(struct PlayState* play, CollisionCheckContext*
         Math3D_TriNorm(&D_801EE038, &atQuad->dim.quad[1], &atQuad->dim.quad[0], &atQuad->dim.quad[2]);
 
         for (acTrisElem = acTris->elements; acTrisElem < &acTris->elements[acTris->count]; acTrisElem++) {
-            if (CollisionCheck_SkipBump(&acTrisElem->base)) {
+            if (CollisionCheck_IsElementNotAC(&acTrisElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acTrisElem->base)) {
@@ -2573,10 +2580,10 @@ void CollisionCheck_AC_QuadVsQuad(struct PlayState* play, CollisionCheckContext*
     s32 i;
     s32 j;
 
-    if (CollisionCheck_SkipTouch(&atQuad->elem)) {
+    if (CollisionCheck_IsElementNotAT(&atQuad->elem)) {
         return;
     }
-    if (CollisionCheck_SkipBump(&acQuad->elem)) {
+    if (CollisionCheck_IsElementNotAC(&acQuad->elem)) {
         return;
     }
     if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acQuad->elem)) {
@@ -2614,10 +2621,10 @@ void CollisionCheck_AC_QuadVsSphere(struct PlayState* play, CollisionCheckContex
     Vec3f hitPos;
     ColliderSphere* acSph = (ColliderSphere*)acCol;
 
-    if (CollisionCheck_SkipTouch(&atQuad->elem)) {
+    if (CollisionCheck_IsElementNotAT(&atQuad->elem)) {
         return;
     }
-    if (CollisionCheck_SkipBump(&acSph->elem) || CollisionCheck_NoSharedFlags(&atQuad->elem, &acSph->elem)) {
+    if (CollisionCheck_IsElementNotAC(&acSph->elem) || CollisionCheck_NoSharedFlags(&atQuad->elem, &acSph->elem)) {
         return;
     }
 
@@ -2650,12 +2657,12 @@ void CollisionCheck_AC_SphereVsJntSph(struct PlayState* play, CollisionCheckCont
     f32 centerDist;
 
     if ((acJntSph->count > 0) && (acJntSph->elements != NULL)) {
-        if (CollisionCheck_SkipTouch(&atSph->elem)) {
+        if (CollisionCheck_IsElementNotAT(&atSph->elem)) {
             return;
         }
 
         for (acJntSphElem = acJntSph->elements; acJntSphElem < &acJntSph->elements[acJntSph->count]; acJntSphElem++) {
-            if (CollisionCheck_SkipBump(&acJntSphElem->base)) {
+            if (CollisionCheck_IsElementNotAC(&acJntSphElem->base)) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atSph->elem, &acJntSphElem->base)) {
@@ -2696,10 +2703,10 @@ void CollisionCheck_AC_SphereVsCylinder(struct PlayState* play, CollisionCheckCo
     f32 overlapSize;
     f32 centerDist;
 
-    if (CollisionCheck_SkipTouch(&atSph->elem)) {
+    if (CollisionCheck_IsElementNotAT(&atSph->elem)) {
         return;
     }
-    if (CollisionCheck_SkipBump(&acCyl->elem)) {
+    if (CollisionCheck_IsElementNotAC(&acCyl->elem)) {
         return;
     }
     if (CollisionCheck_NoSharedFlags(&atSph->elem, &acCyl->elem)) {
@@ -2743,12 +2750,12 @@ void CollisionCheck_AC_SphereVsTris(struct PlayState* play, CollisionCheckContex
     ColliderTrisElement* acTrisElem;
     Vec3f hitPos;
 
-    if (CollisionCheck_SkipTouch(&atSph->elem)) {
+    if (CollisionCheck_IsElementNotAT(&atSph->elem)) {
         return;
     }
 
     for (acTrisElem = acTris->elements; acTrisElem < &acTris->elements[acTris->count]; acTrisElem++) {
-        if (CollisionCheck_SkipBump(&acTrisElem->base)) {
+        if (CollisionCheck_IsElementNotAC(&acTrisElem->base)) {
             continue;
         }
         if (CollisionCheck_NoSharedFlags(&atSph->elem, &acTrisElem->base)) {
@@ -2776,10 +2783,10 @@ void CollisionCheck_AC_SphereVsQuad(struct PlayState* play, CollisionCheckContex
     Vec3f hitPos;
     ColliderQuad* acQuad = (ColliderQuad*)acCol;
 
-    if (CollisionCheck_SkipTouch(&atSph->elem)) {
+    if (CollisionCheck_IsElementNotAT(&atSph->elem)) {
         return;
     }
-    if (CollisionCheck_SkipBump(&acQuad->elem) || CollisionCheck_NoSharedFlags(&atSph->elem, &acQuad->elem)) {
+    if (CollisionCheck_IsElementNotAC(&acQuad->elem) || CollisionCheck_NoSharedFlags(&atSph->elem, &acQuad->elem)) {
         return;
     }
 
@@ -2808,10 +2815,10 @@ void CollisionCheck_AC_SphereVsSphere(struct PlayState* play, CollisionCheckCont
     f32 overlapSize;
     f32 centerDist;
 
-    if (CollisionCheck_SkipTouch(&atSph->elem)) {
+    if (CollisionCheck_IsElementNotAT(&atSph->elem)) {
         return;
     }
-    if (CollisionCheck_SkipBump(&acSph->elem)) {
+    if (CollisionCheck_IsElementNotAC(&acSph->elem)) {
         return;
     }
     if (CollisionCheck_NoSharedFlags(&atSph->elem, &acSph->elem)) {
@@ -2846,14 +2853,14 @@ void CollisionCheck_SetJntSphHitFX(struct PlayState* play, CollisionCheckContext
     ColliderJntSphElement* jntSphElem;
 
     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)) {
+        if ((jntSphElem->base.acElemFlags & ACELEM_DRAW_HITMARK) && (jntSphElem->base.acHitElem != NULL) &&
+            !(jntSphElem->base.acHitElem->atElemFlags & ATELEM_DREW_HITMARK)) {
             Vec3f hitPos;
 
-            Math_Vec3s_ToVec3f(&hitPos, &jntSphElem->base.bumper.hitPos);
+            Math_Vec3s_ToVec3f(&hitPos, &jntSphElem->base.acDmgInfo.hitPos);
             CollisionCheck_HitEffects(play, jntSphElem->base.acHit, jntSphElem->base.acHitElem, &jntSph->base,
                                       &jntSphElem->base, &hitPos);
-            jntSphElem->base.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
+            jntSphElem->base.acHitElem->atElemFlags |= ATELEM_DREW_HITMARK;
             return;
         }
     }
@@ -2865,13 +2872,13 @@ void CollisionCheck_SetJntSphHitFX(struct PlayState* play, CollisionCheckContext
 void CollisionCheck_SetCylHitFX(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
     ColliderCylinder* cyl = (ColliderCylinder*)col;
 
-    if ((cyl->elem.bumperFlags & BUMP_DRAW_HITMARK) && (cyl->elem.acHitElem != NULL) &&
-        !(cyl->elem.acHitElem->toucherFlags & TOUCH_DREW_HITMARK)) {
+    if ((cyl->elem.acElemFlags & ACELEM_DRAW_HITMARK) && (cyl->elem.acHitElem != NULL) &&
+        !(cyl->elem.acHitElem->atElemFlags & ATELEM_DREW_HITMARK)) {
         Vec3f hitPos;
 
-        Math_Vec3s_ToVec3f(&hitPos, &cyl->elem.bumper.hitPos);
+        Math_Vec3s_ToVec3f(&hitPos, &cyl->elem.acDmgInfo.hitPos);
         CollisionCheck_HitEffects(play, cyl->elem.acHit, cyl->elem.acHitElem, &cyl->base, &cyl->elem, &hitPos);
-        cyl->elem.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
+        cyl->elem.acHitElem->atElemFlags |= ATELEM_DREW_HITMARK;
     }
 }
 
@@ -2883,14 +2890,14 @@ void CollisionCheck_SetTrisHitFX(struct PlayState* play, CollisionCheckContext*
     ColliderTrisElement* trisElem;
 
     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)) {
+        if ((trisElem->base.acElemFlags & ACELEM_DRAW_HITMARK) && (trisElem->base.acHitElem != NULL) &&
+            !(trisElem->base.acHitElem->atElemFlags & ATELEM_DREW_HITMARK)) {
             Vec3f hitPos;
 
-            Math_Vec3s_ToVec3f(&hitPos, &trisElem->base.bumper.hitPos);
+            Math_Vec3s_ToVec3f(&hitPos, &trisElem->base.acDmgInfo.hitPos);
             CollisionCheck_HitEffects(play, trisElem->base.acHit, trisElem->base.acHitElem, &tris->base,
                                       &trisElem->base, &hitPos);
-            trisElem->base.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
+            trisElem->base.acHitElem->atElemFlags |= ATELEM_DREW_HITMARK;
             return;
         }
     }
@@ -2902,13 +2909,13 @@ void CollisionCheck_SetTrisHitFX(struct PlayState* play, CollisionCheckContext*
 void CollisionCheck_SetQuadHitFX(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
     ColliderQuad* quad = (ColliderQuad*)col;
 
-    if ((quad->elem.bumperFlags & BUMP_DRAW_HITMARK) && (quad->elem.acHitElem != NULL) &&
-        !(quad->elem.acHitElem->toucherFlags & TOUCH_DREW_HITMARK)) {
+    if ((quad->elem.acElemFlags & ACELEM_DRAW_HITMARK) && (quad->elem.acHitElem != NULL) &&
+        !(quad->elem.acHitElem->atElemFlags & ATELEM_DREW_HITMARK)) {
         Vec3f hitPos;
 
-        Math_Vec3s_ToVec3f(&hitPos, &quad->elem.bumper.hitPos);
+        Math_Vec3s_ToVec3f(&hitPos, &quad->elem.acDmgInfo.hitPos);
         CollisionCheck_HitEffects(play, quad->elem.acHit, quad->elem.acHitElem, &quad->base, &quad->elem, &hitPos);
-        quad->elem.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
+        quad->elem.acHitElem->atElemFlags |= ATELEM_DREW_HITMARK;
     }
 }
 
@@ -2918,13 +2925,13 @@ void CollisionCheck_SetQuadHitFX(struct PlayState* play, CollisionCheckContext*
 void CollisionCheck_SetSphereHitFX(struct PlayState* play, CollisionCheckContext* colChkCtx, Collider* col) {
     ColliderSphere* sph = (ColliderSphere*)col;
 
-    if ((sph->elem.bumperFlags & BUMP_DRAW_HITMARK) && (sph->elem.acHitElem != NULL) &&
-        !(sph->elem.acHitElem->toucherFlags & TOUCH_DREW_HITMARK)) {
+    if ((sph->elem.acElemFlags & ACELEM_DRAW_HITMARK) && (sph->elem.acHitElem != NULL) &&
+        !(sph->elem.acHitElem->atElemFlags & ATELEM_DREW_HITMARK)) {
         Vec3f hitPos;
 
-        Math_Vec3s_ToVec3f(&hitPos, &sph->elem.bumper.hitPos);
+        Math_Vec3s_ToVec3f(&hitPos, &sph->elem.acDmgInfo.hitPos);
         CollisionCheck_HitEffects(play, sph->elem.acHit, sph->elem.acHitElem, &sph->base, &sph->elem, &hitPos);
-        sph->elem.acHitElem->toucherFlags |= TOUCH_DREW_HITMARK;
+        sph->elem.acHitElem->atElemFlags |= ATELEM_DREW_HITMARK;
     }
 }
 
@@ -3024,7 +3031,7 @@ void CollisionCheck_AC(struct PlayState* play, CollisionCheckContext* colChkCtx,
  * Iterates through all AT colliders, testing them for AC collisions with each AC collider, setting the info regarding
  * the collision for each AC and AT collider that collided. Then spawns hitmarks and plays sound effects for each
  * successful collision. To collide, an AT collider must share a type (AC_TYPE_PLAYER, AC_TYPE_ENEMY, or AC_TYPE_OTHER)
- * with the AC collider and the toucher and bumper elements that overlapped must share a dmgFlag.
+ * with the AC collider and the atDmgInfo and acDmgInfo elements that overlapped must share a dmgFlag.
  */
 void CollisionCheck_AT(struct PlayState* play, CollisionCheckContext* colChkCtx) {
     Collider** acColP;
@@ -3536,7 +3543,7 @@ void CollisionCheck_ApplyDamage(struct PlayState* play, CollisionCheckContext* c
     if ((col->actor == NULL) || !(col->acFlags & AC_HIT)) {
         return;
     }
-    if (!(elem->bumperFlags & BUMP_HIT) || (elem->bumperFlags & BUMP_NO_DAMAGE)) {
+    if (!(elem->acElemFlags & ACELEM_HIT) || (elem->acElemFlags & ACELEM_NO_DAMAGE)) {
         return;
     }
 
@@ -3544,16 +3551,16 @@ void CollisionCheck_ApplyDamage(struct PlayState* play, CollisionCheckContext* c
     atElem = elem->acHitElem;
 
     if ((atCol != NULL) && (atElem != NULL) && (col != NULL) && (elem != NULL)) {
-        damage = CollisionCheck_GetDamageAndEffectOnBumper(atCol, atElem, col, elem, &effect);
+        damage = CollisionCheck_GetDamageAndEffectOnElementAC(atCol, atElem, col, elem, &effect);
 
-        if (CollisionCheck_GetToucherDamage(atCol, atElem, col, elem) != 0) {
+        if (CollisionCheck_GetElementATDamage(atCol, atElem, col, elem) != 0) {
             if (damage < 1.0f) {
                 finalDamage = 0.0f;
                 if (effect == 0) {
                     return;
                 }
             } else {
-                finalDamage = CollisionCheck_ApplyBumperDefense(damage, elem);
+                finalDamage = CollisionCheck_ApplyElementATDefense(damage, elem);
                 if ((finalDamage < 1.0f) && (effect == 0)) {
                     return;
                 }
@@ -3562,7 +3569,7 @@ void CollisionCheck_ApplyDamage(struct PlayState* play, CollisionCheckContext* c
         if (col->actor->colChkInfo.damageTable != NULL) {
             col->actor->colChkInfo.damageEffect = effect;
         }
-        if (!(col->acFlags & AC_HARD) || ((col->acFlags & AC_HARD) && (atElem->toucher.dmgFlags == 0x20000000))) {
+        if (!(col->acFlags & AC_HARD) || ((col->acFlags & AC_HARD) && (atElem->atDmgInfo.dmgFlags == 0x20000000))) {
             if (col->actor->colChkInfo.damage < finalDamage) {
                 col->actor->colChkInfo.damage = finalDamage;
             }
diff --git a/src/code/z_en_a_keep.c b/src/code/z_en_a_keep.c
index d062e0e1f..637485e9d 100644
--- a/src/code/z_en_a_keep.c
+++ b/src/code/z_en_a_keep.c
@@ -27,7 +27,7 @@ ActorProfile En_A_Obj_Profile = {
 
 static ColliderCylinderInit sCylinderInit = {
     {
-        COLTYPE_NONE,
+        COL_MATERIAL_NONE,
         AT_NONE,
         AC_NONE,
         OC1_ON | OC1_TYPE_ALL,
@@ -35,11 +35,11 @@ static ColliderCylinderInit sCylinderInit = {
         COLSHAPE_CYLINDER,
     },
     {
-        ELEMTYPE_UNK0,
+        ELEM_MATERIAL_UNK0,
         { 0x00000000, 0x00, 0x00 },
         { 0xF7CFFFFF, 0x00, 0x00 },
-        TOUCH_NONE,
-        BUMP_NONE,
+        ATELEM_NONE,
+        ACELEM_NONE,
         OCELEM_ON,
     },
     { 25, 60, 0, { 0, 0, 0 } },
diff --git a/src/code/z_en_item00.c b/src/code/z_en_item00.c
index 2101ff71f..b0bc32675 100644
--- a/src/code/z_en_item00.c
+++ b/src/code/z_en_item00.c
@@ -39,7 +39,7 @@ ActorProfile En_Item00_Profile = {
 
 static ColliderCylinderInit sCylinderInit = {
     {
-        COLTYPE_NONE,
+        COL_MATERIAL_NONE,
         AT_NONE,
         AC_ON | AT_TYPE_PLAYER,
         OC1_NONE,
@@ -47,11 +47,11 @@ static ColliderCylinderInit sCylinderInit = {
         COLSHAPE_CYLINDER,
     },
     {
-        ELEMTYPE_UNK0,
+        ELEM_MATERIAL_UNK0,
         { 0x00000000, 0x00, 0x00 },
         { 0x00000010, 0x00, 0x00 },
-        TOUCH_NONE | TOUCH_SFX_NORMAL,
-        BUMP_ON,
+        ATELEM_NONE | ATELEM_SFX_NORMAL,
+        ACELEM_ON,
         OCELEM_NONE,
     },
     { 10, 30, 0, { 0, 0, 0 } },
diff --git a/src/code/z_fireobj.c b/src/code/z_fireobj.c
index 162439a53..c4a4630f9 100644
--- a/src/code/z_fireobj.c
+++ b/src/code/z_fireobj.c
@@ -4,7 +4,7 @@
 
 ColliderCylinderInit sFireObjCollisionInit = {
     {
-        COLTYPE_NONE,
+        COL_MATERIAL_NONE,
         AT_NONE,
         AC_ON | AC_TYPE_PLAYER,
         OC1_NONE,
@@ -12,11 +12,11 @@ ColliderCylinderInit sFireObjCollisionInit = {
         COLSHAPE_CYLINDER,
     },
     {
-        ELEMTYPE_UNK4,
+        ELEM_MATERIAL_UNK4,
         { 0x00000000, 0x00, 0x00 },
         { 0x00000820, 0x00, 0x00 },
-        TOUCH_NONE | TOUCH_SFX_NORMAL,
-        BUMP_ON,
+        ATELEM_NONE | ATELEM_SFX_NORMAL,
+        ACELEM_ON,
         OCELEM_NONE,
     },
     { 18, 67, 0, { 0, 0, 0 } },
@@ -223,13 +223,13 @@ void FireObj_Update(PlayState* play, FireObj* fire, Actor* actor) {
     FireObj_UpdateStateTransitions(play, fire);
     if (fire->state == FIRE_STATE_NOT_LIT) {
         if ((fire->collision.base.acFlags & AC_HIT) &&
-            (fire->collision.elem.acHitElem->toucher.dmgFlags & DMG_FIRE_ARROW)) {
+            (fire->collision.elem.acHitElem->atDmgInfo.dmgFlags & DMG_FIRE_ARROW)) {
             FireObj_SetState(fire, fire->dynamicSizeStep, FIRE_STATE_GROWING);
         }
     } else if ((fire->collision.base.acFlags & AC_HIT) && (arrow->actor.update != NULL) &&
                (arrow->actor.id == ACTOR_EN_ARROW)) {
         arrow->actor.params = 0;
-        arrow->collider.elem.toucher.dmgFlags = DMG_FIRE_ARROW;
+        arrow->collider.elem.atDmgInfo.dmgFlags = DMG_FIRE_ARROW;
     }
     fire->collision.dim.pos.x = fire->position.x;
     fire->collision.dim.pos.y = fire->position.y;
diff --git a/src/code/z_player_lib.c b/src/code/z_player_lib.c
index a81acfc1d..15ba7869a 100644
--- a/src/code/z_player_lib.c
+++ b/src/code/z_player_lib.c
@@ -2415,17 +2415,17 @@ s32 func_80126440(PlayState* play, ColliderQuad* collider, WeaponInfo* weaponInf
     return true;
 }
 
-u8 sPlayerShieldCollisionTypes[PLAYER_SHIELD_MAX] = {
-    COLTYPE_METAL, // PLAYER_SHIELD_NONE
-    COLTYPE_METAL, // PLAYER_SHIELD_HEROS_SHIELD
-    COLTYPE_METAL, // PLAYER_SHIELD_MIRROR_SHIELD
+u8 sPlayerShieldColMaterials[PLAYER_SHIELD_MAX] = {
+    COL_MATERIAL_METAL, // PLAYER_SHIELD_NONE
+    COL_MATERIAL_METAL, // PLAYER_SHIELD_HEROS_SHIELD
+    COL_MATERIAL_METAL, // PLAYER_SHIELD_MIRROR_SHIELD
 };
 
 void Player_UpdateShieldCollider(PlayState* play, Player* player, ColliderQuad* collider, Vec3f quadSrc[4]) {
     if (player->stateFlags1 & PLAYER_STATE1_400000) {
         Vec3f quadDest[4];
 
-        player->shieldQuad.base.colType = sPlayerShieldCollisionTypes[player->currentShield];
+        player->shieldQuad.base.colMaterial = sPlayerShieldColMaterials[player->currentShield];
         Matrix_MultVec3f(&quadSrc[0], &quadDest[0]);
         Matrix_MultVec3f(&quadSrc[1], &quadDest[1]);
         Matrix_MultVec3f(&quadSrc[2], &quadDest[2]);