Colliders: change "touch, bump" to AT and AC (elems) (#1637)

* toucherFlags, bumperFlags -> atElemFlags, acElemFlags

* TOUCH_ -> ATELEM_

* BUMP_ -> ACELEM_

* ColliderElementTouch,Bump -> ColliderElementDamageInfoAT,AC

* toucher,bumper -> atDmgInfo,acDmgInfo

* Update docs and zcolchk funcs names

* run formatter

* remove the last mentions of "bump" for colliders

* Update renamed functions in disasm

4 files changed, 131 insertions, 135 deletions

diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 96d8244d9..d9b7f579c 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -4324,24 +4324,24 @@ u8 Actor_ApplyDamage(Actor* actor) {
 void Actor_SetDropFlag(Actor* actor, ColliderElement* elem, s32 freezeFlag) {
     if (elem->acHitElem == NULL) {
         actor->dropFlag = 0x00;
-    } else if (freezeFlag && (elem->acHitElem->toucher.dmgFlags & (DMG_UNKNOWN_1 | DMG_MAGIC_ICE | DMG_MAGIC_FIRE))) {
-        actor->freezeTimer = elem->acHitElem->toucher.damage;
+    } else if (freezeFlag && (elem->acHitElem->atDmgInfo.dmgFlags & (DMG_UNKNOWN_1 | DMG_MAGIC_ICE | DMG_MAGIC_FIRE))) {
+        actor->freezeTimer = elem->acHitElem->atDmgInfo.damage;
         actor->dropFlag = 0x00;
-    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_FIRE) {
+    } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_FIRE) {
         actor->dropFlag = 0x01;
-    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_ICE) {
+    } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_ICE) {
         actor->dropFlag = 0x02;
-    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK1) {
+    } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_UNK1) {
         actor->dropFlag = 0x04;
-    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK2) {
+    } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_UNK2) {
         actor->dropFlag = 0x08;
-    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK3) {
+    } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_UNK3) {
         actor->dropFlag = 0x10;
-    } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_LIGHT) {
+    } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_LIGHT) {
         actor->dropFlag = 0x20;
-    } else if (elem->acHitElem->toucher.dmgFlags & DMG_MAGIC_LIGHT) {
+    } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_MAGIC_LIGHT) {
         if (freezeFlag) {
-            actor->freezeTimer = elem->acHitElem->toucher.damage;
+            actor->freezeTimer = elem->acHitElem->atDmgInfo.damage;
         }
         actor->dropFlag = 0x40;
     } else {
@@ -4361,24 +4361,24 @@ void Actor_SetDropFlagJntSph(Actor* actor, ColliderJntSph* jntSph, s32 freezeFla
         if (elem->acHitElem == NULL) {
             flag = 0x00;
         } else if (freezeFlag &&
-                   (elem->acHitElem->toucher.dmgFlags & (DMG_UNKNOWN_1 | DMG_MAGIC_ICE | DMG_MAGIC_FIRE))) {
-            actor->freezeTimer = elem->acHitElem->toucher.damage;
+                   (elem->acHitElem->atDmgInfo.dmgFlags & (DMG_UNKNOWN_1 | DMG_MAGIC_ICE | DMG_MAGIC_FIRE))) {
+            actor->freezeTimer = elem->acHitElem->atDmgInfo.damage;
             flag = 0x00;
-        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_FIRE) {
+        } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_FIRE) {
             flag = 0x01;
-        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_ICE) {
+        } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_ICE) {
             flag = 0x02;
-        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK1) {
+        } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_UNK1) {
             flag = 0x04;
-        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK2) {
+        } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_UNK2) {
             flag = 0x08;
-        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_UNK3) {
+        } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_UNK3) {
             flag = 0x10;
-        } else if (elem->acHitElem->toucher.dmgFlags & DMG_ARROW_LIGHT) {
+        } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_ARROW_LIGHT) {
             flag = 0x20;
-        } else if (elem->acHitElem->toucher.dmgFlags & DMG_MAGIC_LIGHT) {
+        } else if (elem->acHitElem->atDmgInfo.dmgFlags & DMG_MAGIC_LIGHT) {
             if (freezeFlag) {
-                actor->freezeTimer = elem->acHitElem->toucher.damage;
+                actor->freezeTimer = elem->acHitElem->atDmgInfo.damage;
             }
             flag = 0x40;
         } else {
diff --git a/src/code/z_collision_check.c b/src/code/z_collision_check.c
index 57510f3c4..14822cf1c 100644
--- a/src/code/z_collision_check.c
+++ b/src/code/z_collision_check.c
@@ -139,18 +139,19 @@ void Collider_ResetOCBase(PlayState* play, Collider* col) {
     col->ocFlags2 &= ~OC2_HIT_PLAYER;
 }
 
-s32 Collider_InitElementTouch(PlayState* play, ColliderElementTouch* touch) {
-    static ColliderElementTouch init = { 0x00000000, 0, 0 };
+s32 Collider_InitElementDamageInfoAT(PlayState* play, ColliderElementDamageInfoAT* atDmgInfo) {
+    static ColliderElementDamageInfoAT init = { 0x00000000, 0, 0 };
 
-    *touch = init;
+    *atDmgInfo = init;
     return true;
 }
 
-s32 Collider_DestroyElementTouch(PlayState* play, ColliderElementTouch* touch) {
+s32 Collider_DestroyElementDamageInfoAT(PlayState* play, ColliderElementDamageInfoAT* atDmgInfo) {
     return true;
 }
 
-s32 Collider_SetElementTouch(PlayState* play, ColliderElementTouch* dest, ColliderElementTouch* src) {
+s32 Collider_SetElementDamageInfoAT(PlayState* play, ColliderElementDamageInfoAT* dest,
+                                    ColliderElementDamageInfoAT* src) {
     dest->dmgFlags = src->dmgFlags;
     dest->effect = src->effect;
     dest->damage = src->damage;
@@ -160,51 +161,52 @@ s32 Collider_SetElementTouch(PlayState* play, ColliderElementTouch* dest, Collid
 void Collider_ResetATElement_Unk(PlayState* play, ColliderElement* elem) {
 }
 
-s32 Collider_InitElementBump(PlayState* play, ColliderElementBump* bump) {
-    static ColliderElementBump init = { 0xFFCFFFFF, 0, 0, { 0, 0, 0 } };
+s32 Collider_InitElementDamageInfoAC(PlayState* play, ColliderElementDamageInfoAC* acDmgInfo) {
+    static ColliderElementDamageInfoAC init = { 0xFFCFFFFF, 0, 0, { 0, 0, 0 } };
 
-    *bump = init;
+    *acDmgInfo = init;
     return true;
 }
 
-s32 Collider_DestroyElementBump(PlayState* play, ColliderElementBump* bump) {
+s32 Collider_DestroyElementDamageInfoAC(PlayState* play, ColliderElementDamageInfoAC* acDmgInfo) {
     return true;
 }
 
-s32 Collider_SetElementBump(PlayState* play, ColliderElementBump* bump, ColliderElementBumpInit* init) {
-    bump->dmgFlags = init->dmgFlags;
-    bump->effect = init->effect;
-    bump->defense = init->defense;
+s32 Collider_SetElementDamageInfoAC(PlayState* play, ColliderElementDamageInfoAC* acDmgInfo,
+                                    ColliderElementDamageInfoACInit* init) {
+    acDmgInfo->dmgFlags = init->dmgFlags;
+    acDmgInfo->effect = init->effect;
+    acDmgInfo->defense = init->defense;
     return true;
 }
 
 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,
+        ELEMTYPE_UNK0, ATELEM_NONE,
+        ACELEM_NONE,   OCELEM_NONE,
         NULL,          NULL,
         NULL,          NULL,
     };
 
     *elem = init;
-    Collider_InitElementTouch(play, &elem->toucher);
-    Collider_InitElementBump(play, &elem->bumper);
+    Collider_InitElementDamageInfoAT(play, &elem->atDmgInfo);
+    Collider_InitElementDamageInfoAC(play, &elem->acDmgInfo);
     return true;
 }
 
 s32 Collider_DestroyElement(PlayState* play, ColliderElement* elem) {
-    Collider_DestroyElementTouch(play, &elem->toucher);
-    Collider_DestroyElementBump(play, &elem->bumper);
+    Collider_DestroyElementDamageInfoAT(play, &elem->atDmgInfo);
+    Collider_DestroyElementDamageInfoAC(play, &elem->acDmgInfo);
     return true;
 }
 
 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;
+    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 true;
 }
@@ -212,15 +214,15 @@ s32 Collider_SetElement(PlayState* play, ColliderElement* elem, ColliderElementI
 void Collider_ResetATElement(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_ResetATElement_Unk(play, elem);
 }
 
 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->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;
 }
@@ -929,7 +931,7 @@ s32 Collider_QuadSetNearestAC(PlayState* play, ColliderQuad* quad, Vec3f* hitPos
     f32 acDistSq;
     Vec3f dcMid;
 
-    if (!(quad->elem.toucherFlags & TOUCH_NEAREST)) {
+    if (!(quad->elem.atElemFlags & ATELEM_NEAREST)) {
         return true;
     }
     Math_Vec3s_ToVec3f(&dcMid, &quad->dim.dcMid);
@@ -1366,21 +1368,15 @@ s32 CollisionCheck_SetOCLine(PlayState* play, CollisionCheckContext* colChkCtx,
     return index;
 }
 
-/**
- * Skips AT elements that are off.
- */
-s32 CollisionCheck_SkipElementTouch(ColliderElement* elem) {
-    if (!(elem->toucherFlags & TOUCH_ON)) {
+s32 CollisionCheck_IsElementNotAT(ColliderElement* elem) {
+    if (!(elem->atElemFlags & ATELEM_ON)) {
         return true;
     }
     return false;
 }
 
-/**
- * Skips AC elements that are off.
- */
-s32 CollisionCheck_SkipElementBump(ColliderElement* elem) {
-    if (!(elem->bumperFlags & BUMP_ON)) {
+s32 CollisionCheck_IsElementNotAC(ColliderElement* elem) {
+    if (!(elem->acElemFlags & ACELEM_ON)) {
         return true;
     }
     return false;
@@ -1390,7 +1386,7 @@ s32 CollisionCheck_SkipElementBump(ColliderElement* elem) {
  * 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;
@@ -1538,9 +1534,9 @@ 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, ColliderElement* elem, Collider* collider, Vec3f* hitPos) {
-    s32 flags = elem->toucherFlags & TOUCH_SFX_MASK;
+    s32 flags = elem->atElemFlags & ATELEM_SFX_MASK;
 
-    if (flags == TOUCH_SFX_NORMAL && collider->colType != COLTYPE_METAL) {
+    if (flags == ATELEM_SFX_NORMAL && collider->colType != COLTYPE_METAL) {
         EffectSsHitMark_SpawnFixedScale(play, EFFECT_HITMARK_WHITE, hitPos);
         if (collider->actor == NULL) {
             Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_BOUND, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
@@ -1549,14 +1545,14 @@ void CollisionCheck_HitSolid(PlayState* play, ColliderElement* elem, Collider* c
             Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_BOUND, &collider->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
                                  &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
         }
-    } else if (flags == TOUCH_SFX_NORMAL) { // collider->colType == COLTYPE_METAL
+    } else if (flags == ATELEM_SFX_NORMAL) { // collider->colType == COLTYPE_METAL
         EffectSsHitMark_SpawnFixedScale(play, EFFECT_HITMARK_METAL, hitPos);
         if (collider->actor == NULL) {
             CollisionCheck_SpawnShieldParticlesMetal(play, hitPos);
         } else {
             CollisionCheck_SpawnShieldParticlesMetalSfx(play, hitPos, &collider->actor->projectedPos);
         }
-    } else if (flags == TOUCH_SFX_HARD) {
+    } else if (flags == ATELEM_SFX_HARD) {
         EffectSsHitMark_SpawnFixedScale(play, EFFECT_HITMARK_WHITE, hitPos);
         if (collider->actor == NULL) {
             Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_BOUND, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
@@ -1565,7 +1561,7 @@ void CollisionCheck_HitSolid(PlayState* play, ColliderElement* elem, Collider* c
             Audio_PlaySfxGeneral(NA_SE_IT_SHIELD_BOUND, &collider->actor->projectedPos, 4, &gSfxDefaultFreqAndVolScale,
                                  &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
         }
-    } else if (flags == TOUCH_SFX_WOOD) {
+    } else if (flags == ATELEM_SFX_WOOD) {
         EffectSsHitMark_SpawnFixedScale(play, EFFECT_HITMARK_DUST, hitPos);
         if (collider->actor == NULL) {
             Audio_PlaySfxGeneral(NA_SE_IT_REFLECTION_WOOD, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
@@ -1655,10 +1651,10 @@ static HitInfo sHitInfo[] = {
  */
 void CollisionCheck_HitEffects(PlayState* play, Collider* atCol, ColliderElement* atElem, Collider* acCol,
                                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 (acCol->actor != NULL) {
@@ -1677,7 +1673,7 @@ void CollisionCheck_HitEffects(PlayState* play, Collider* atCol, ColliderElement
             }
         } else if (sHitInfo[acCol->colType].effect != HIT_NONE) {
             EffectSsHitMark_SpawnFixedScale(play, sHitInfo[acCol->colType].effect, hitPos);
-            if (!(acElem->bumperFlags & BUMP_NO_SWORD_SFX)) {
+            if (!(acElem->acElemFlags & ACELEM_NO_SWORD_SFX)) {
                 CollisionCheck_SwordHitAudio(atCol, acElem);
             }
         }
@@ -1709,33 +1705,33 @@ s32 CollisionCheck_SetATvsAC(PlayState* play, Collider* atCol, ColliderElement*
     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->atHitElem = acElem;
-        atElem->toucherFlags |= TOUCH_HIT;
+        atElem->atElemFlags |= ATELEM_HIT;
         if (atCol->actor != NULL) {
-            atCol->actor->colChkInfo.atHitEffect = acElem->bumper.effect;
+            atCol->actor->colChkInfo.atHitEffect = acElem->acDmgInfo.effect;
         }
     }
     acCol->acFlags |= AC_HIT;
     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;
-    if (!(atElem->toucherFlags & TOUCH_AT_HITMARK) && acCol->colType != COLTYPE_METAL &&
+    acElem->acDmgInfo.hitPos.x = hitPos->x;
+    acElem->acDmgInfo.hitPos.y = hitPos->y;
+    acElem->acDmgInfo.hitPos.z = hitPos->z;
+    if (!(atElem->atElemFlags & ATELEM_AT_HITMARK) && acCol->colType != COLTYPE_METAL &&
         acCol->colType != COLTYPE_WOOD && acCol->colType != COLTYPE_HARD) {
-        acElem->bumperFlags |= BUMP_DRAW_HITMARK;
+        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 true;
 }
@@ -1751,12 +1747,12 @@ void CollisionCheck_ATJntSphVsACJntSph(PlayState* play, CollisionCheckContext* c
 
     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) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base) == true) {
                 continue;
             }
             for (acJntSphElem = acJntSph->elements; acJntSphElem < acJntSph->elements + acJntSph->count;
                  acJntSphElem++) {
-                if (CollisionCheck_SkipElementBump(&acJntSphElem->base) == true) {
+                if (CollisionCheck_IsElementNotAC(&acJntSphElem->base) == true) {
                     continue;
                 }
                 if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acJntSphElem->base) == true) {
@@ -1803,11 +1799,11 @@ void CollisionCheck_ATJntSphVsACCyl(PlayState* play, CollisionCheckContext* colC
     f32 centerDist;
 
     if (atJntSph->count > 0 && atJntSph->elements != NULL && acCyl->dim.radius > 0 && acCyl->dim.height > 0) {
-        if (CollisionCheck_SkipElementBump(&acCyl->elem) == true) {
+        if (CollisionCheck_IsElementNotAC(&acCyl->elem) == true) {
             return;
         }
         for (atJntSphElem = atJntSph->elements; atJntSphElem < atJntSph->elements + atJntSph->count; atJntSphElem++) {
-            if (CollisionCheck_SkipElementTouch(&atJntSphElem->base) == true) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base) == true) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acCyl->elem) == true) {
@@ -1855,11 +1851,11 @@ void CollisionCheck_ATCylVsACJntSph(PlayState* play, CollisionCheckContext* colC
     ColliderJntSphElement* acJntSphElem;
 
     if (acJntSph->count > 0 && acJntSph->elements != NULL && atCyl->dim.radius > 0 && atCyl->dim.height > 0) {
-        if (CollisionCheck_SkipElementTouch(&atCyl->elem) == true) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem) == true) {
             return;
         }
         for (acJntSphElem = acJntSph->elements; acJntSphElem < acJntSph->elements + acJntSph->count; acJntSphElem++) {
-            if (CollisionCheck_SkipElementBump(&acJntSphElem->base) == true) {
+            if (CollisionCheck_IsElementNotAC(&acJntSphElem->base) == true) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acJntSphElem->base) == true) {
@@ -1910,11 +1906,11 @@ void CollisionCheck_ATJntSphVsACTris(PlayState* play, CollisionCheckContext* col
 
     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) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base) == true) {
                 continue;
             }
             for (acTrisElem = acTris->elements; acTrisElem < acTris->elements + acTris->count; acTrisElem++) {
-                if (CollisionCheck_SkipElementBump(&acTrisElem->base) == true) {
+                if (CollisionCheck_IsElementNotAC(&acTrisElem->base) == true) {
                     continue;
                 }
                 if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acTrisElem->base) == true) {
@@ -1952,11 +1948,11 @@ void CollisionCheck_ATTrisVsACJntSph(PlayState* play, CollisionCheckContext* col
 
     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) {
+            if (CollisionCheck_IsElementNotAC(&acJntSphElem->base) == true) {
                 continue;
             }
             for (atTrisElem = atTris->elements; atTrisElem < atTris->elements + atTris->count; atTrisElem++) {
-                if (CollisionCheck_SkipElementTouch(&atTrisElem->base) == true) {
+                if (CollisionCheck_IsElementNotAT(&atTrisElem->base) == true) {
                     continue;
                 }
                 if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acJntSphElem->base) == true) {
@@ -1994,13 +1990,13 @@ void CollisionCheck_ATJntSphVsACQuad(PlayState* play, CollisionCheckContext* col
     ColliderJntSphElement* atJntSphElem;
 
     if (atJntSph->count > 0 && atJntSph->elements != NULL) {
-        if (CollisionCheck_SkipElementBump(&acQuad->elem) == true) {
+        if (CollisionCheck_IsElementNotAC(&acQuad->elem) == true) {
             return;
         }
         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) {
+            if (CollisionCheck_IsElementNotAT(&atJntSphElem->base) == true) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atJntSphElem->base, &acQuad->elem) == true) {
@@ -2041,13 +2037,13 @@ void CollisionCheck_ATQuadVsACJntSph(PlayState* play, CollisionCheckContext* col
     ColliderJntSphElement* acJntSphElem;
 
     if (acJntSph->count > 0 && acJntSph->elements != NULL) {
-        if (CollisionCheck_SkipElementTouch(&atQuad->elem) == true) {
+        if (CollisionCheck_IsElementNotAT(&atQuad->elem) == true) {
             return;
         }
         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) {
+            if (CollisionCheck_IsElementNotAC(&acJntSphElem->base) == true) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acJntSphElem->base) == true) {
@@ -2091,10 +2087,10 @@ void CollisionCheck_ATCylVsACCyl(PlayState* play, CollisionCheckContext* colChkC
     Vec3f hitPos;
 
     if (atCyl->dim.radius > 0 && atCyl->dim.height > 0 && acCyl->dim.radius > 0 && acCyl->dim.height > 0) {
-        if (CollisionCheck_SkipElementBump(&acCyl->elem) == true) {
+        if (CollisionCheck_IsElementNotAC(&acCyl->elem) == true) {
             return;
         }
-        if (CollisionCheck_SkipElementTouch(&atCyl->elem) == true) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem) == true) {
             return;
         }
         if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acCyl->elem) == true) {
@@ -2128,11 +2124,11 @@ void CollisionCheck_ATCylVsACTris(PlayState* play, CollisionCheckContext* colChk
     Vec3f hitPos;
 
     if (atCyl->dim.radius > 0 && atCyl->dim.height > 0 && acTris->count > 0 && acTris->elements != NULL) {
-        if (CollisionCheck_SkipElementTouch(&atCyl->elem) == true) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem) == true) {
             return;
         }
         for (acTrisElem = acTris->elements; acTrisElem < acTris->elements + acTris->count; acTrisElem++) {
-            if (CollisionCheck_SkipElementBump(&acTrisElem->base) == true) {
+            if (CollisionCheck_IsElementNotAC(&acTrisElem->base) == true) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acTrisElem->base) == true) {
@@ -2162,11 +2158,11 @@ void CollisionCheck_ATTrisVsACCyl(PlayState* play, CollisionCheckContext* colChk
     ColliderCylinder* acCyl = (ColliderCylinder*)acCol;
 
     if (acCyl->dim.radius > 0 && acCyl->dim.height > 0 && atTris->count > 0 && atTris->elements != NULL) {
-        if (CollisionCheck_SkipElementBump(&acCyl->elem) == true) {
+        if (CollisionCheck_IsElementNotAC(&acCyl->elem) == true) {
             return;
         }
         for (atTrisElem = atTris->elements; atTrisElem < atTris->elements + atTris->count; atTrisElem++) {
-            if (CollisionCheck_SkipElementTouch(&atTrisElem->base) == true) {
+            if (CollisionCheck_IsElementNotAT(&atTrisElem->base) == true) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acCyl->elem) == true) {
@@ -2197,8 +2193,8 @@ void CollisionCheck_ATCylVsACQuad(PlayState* play, CollisionCheckContext* colChk
     ColliderQuad* acQuad = (ColliderQuad*)acCol;
 
     if (atCyl->dim.height > 0 && atCyl->dim.radius > 0) {
-        if (CollisionCheck_SkipElementTouch(&atCyl->elem) == true ||
-            CollisionCheck_SkipElementBump(&acQuad->elem) == true) {
+        if (CollisionCheck_IsElementNotAT(&atCyl->elem) == true ||
+            CollisionCheck_IsElementNotAC(&acQuad->elem) == true) {
             return;
         }
         if (CollisionCheck_NoSharedFlags(&atCyl->elem, &acQuad->elem) == true) {
@@ -2253,8 +2249,8 @@ void CollisionCheck_ATQuadVsACCyl(PlayState* play, CollisionCheckContext* colChk
     ColliderCylinder* acCyl = (ColliderCylinder*)acCol;
 
     if (acCyl->dim.height > 0 && acCyl->dim.radius > 0) {
-        if (CollisionCheck_SkipElementBump(&acCyl->elem) == true ||
-            CollisionCheck_SkipElementTouch(&atQuad->elem) == true) {
+        if (CollisionCheck_IsElementNotAC(&acCyl->elem) == true ||
+            CollisionCheck_IsElementNotAT(&atQuad->elem) == true) {
             return;
         }
         if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acCyl->elem) == true) {
@@ -2319,11 +2315,11 @@ void CollisionCheck_ATTrisVsACTris(PlayState* play, CollisionCheckContext* colCh
 
     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) {
+            if (CollisionCheck_IsElementNotAC(&acTrisElem->base) == true) {
                 continue;
             }
             for (atTrisElem = atTris->elements; atTrisElem < atTris->elements + atTris->count; atTrisElem++) {
-                if (CollisionCheck_SkipElementTouch(&atTrisElem->base) == true) {
+                if (CollisionCheck_IsElementNotAT(&atTrisElem->base) == true) {
                     continue;
                 }
                 if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acTrisElem->base) == true) {
@@ -2369,13 +2365,13 @@ void CollisionCheck_ATTrisVsACQuad(PlayState* play, CollisionCheckContext* colCh
     ColliderQuad* acQuad = (ColliderQuad*)acCol;
 
     if (atTris->count > 0 && atTris->elements != NULL) {
-        if (CollisionCheck_SkipElementBump(&acQuad->elem) == true) {
+        if (CollisionCheck_IsElementNotAC(&acQuad->elem) == true) {
             return;
         }
         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) {
+            if (CollisionCheck_IsElementNotAT(&atTrisElem->base) == true) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atTrisElem->base, &acQuad->elem) == true) {
@@ -2416,13 +2412,13 @@ void CollisionCheck_ATQuadVsACTris(PlayState* play, CollisionCheckContext* colCh
     ColliderTrisElement* acTrisElem;
 
     if (acTris->count > 0 && acTris->elements != NULL) {
-        if (CollisionCheck_SkipElementTouch(&atQuad->elem) == true) {
+        if (CollisionCheck_IsElementNotAT(&atQuad->elem) == true) {
             return;
         }
         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) {
+            if (CollisionCheck_IsElementNotAC(&acTrisElem->base) == true) {
                 continue;
             }
             if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acTrisElem->base) == true) {
@@ -2468,10 +2464,10 @@ void CollisionCheck_ATQuadVsACQuad(PlayState* play, CollisionCheckContext* colCh
     s32 i;
     s32 j;
 
-    if (CollisionCheck_SkipElementTouch(&atQuad->elem) == true) {
+    if (CollisionCheck_IsElementNotAT(&atQuad->elem) == true) {
         return;
     }
-    if (CollisionCheck_SkipElementBump(&acQuad->elem) == true) {
+    if (CollisionCheck_IsElementNotAC(&acQuad->elem) == true) {
         return;
     }
     if (CollisionCheck_NoSharedFlags(&atQuad->elem, &acQuad->elem) == true) {
@@ -2522,14 +2518,14 @@ void CollisionCheck_SetJntSphHitFX(PlayState* play, CollisionCheckContext* colCh
     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;
         }
     }
@@ -2538,13 +2534,13 @@ void CollisionCheck_SetJntSphHitFX(PlayState* play, CollisionCheckContext* colCh
 void CollisionCheck_SetCylHitFX(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;
     }
 }
 
@@ -2553,14 +2549,14 @@ void CollisionCheck_SetTrisHitFX(PlayState* play, CollisionCheckContext* colChkC
     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;
         }
     }
@@ -2570,11 +2566,11 @@ void CollisionCheck_SetQuadHitFX(PlayState* play, CollisionCheckContext* colChkC
     ColliderQuad* quad = (ColliderQuad*)col;
     Vec3f hitPos;
 
-    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);
+    if ((quad->elem.acElemFlags & ACELEM_DRAW_HITMARK) && (quad->elem.acHitElem != NULL) &&
+        !(quad->elem.acHitElem->atElemFlags & ATELEM_DREW_HITMARK)) {
+        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;
     }
 }
 
@@ -2661,7 +2657,7 @@ void CollisionCheck_AC(PlayState* play, CollisionCheckContext* colChkCtx, Collid
  * 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 AT and AC elements that overlapped must share a dmgFlag.
  */
 void CollisionCheck_AT(PlayState* play, CollisionCheckContext* colChkCtx) {
     Collider** atColP;
@@ -3052,20 +3048,20 @@ void CollisionCheck_ApplyDamage(PlayState* play, CollisionCheckContext* colChkCt
     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;
     }
 
     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)elem->acHitElem->toucher.damage - elem->bumper.defense;
+        damage = (f32)elem->acHitElem->atDmgInfo.damage - elem->acDmgInfo.defense;
         if (damage < 0) {
             damage = 0;
         }
     } else {
         s32 i;
-        u32 flags = elem->acHitElem->toucher.dmgFlags;
+        u32 flags = elem->acHitElem->atDmgInfo.dmgFlags;
 
         for (i = 0; i < 32; i++, flags >>= 1) {
             if (flags == 1) {
diff --git a/src/code/z_en_a_keep.c b/src/code/z_en_a_keep.c
index 33adc258c..21c5ebd75 100644
--- a/src/code/z_en_a_keep.c
+++ b/src/code/z_en_a_keep.c
@@ -45,8 +45,8 @@ static ColliderCylinderInit sCylinderInit = {
         ELEMTYPE_UNK2,
         { 0x00000000, 0x00, 0x00 },
         { 0xFFCFFFFF, 0x00, 0x00 },
-        TOUCH_NONE,
-        BUMP_ON,
+        ATELEM_NONE,
+        ACELEM_ON,
         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 23bc99f82..9e2e76249 100644
--- a/src/code/z_en_item00.c
+++ b/src/code/z_en_item00.c
@@ -45,8 +45,8 @@ static ColliderCylinderInit sCylinderInit = {
         ELEMTYPE_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 } },