diff --git a/include/functions.h b/include/functions.h
index 5d7c5364f6..ac6ad65dd9 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -776,164 +776,6 @@ void* ActorOverlayTable_FaultAddrConv(void* address, void* param);
 void ActorOverlayTable_Init(void);
 void ActorOverlayTable_Cleanup(void);
 
-void SSNode_SetValue(SSNode* node, s16* polyIndex, u16 next);
-void SSList_SetNull(SSList* ssList);
-void SSNodeList_SetSSListHead(SSNodeList* list, SSList* ssList, s16* polyIndex);
-void DynaSSNodeList_SetSSListHead(DynaSSNodeList* list, SSList* ssList, s16* polyIndex);
-void DynaSSNodeList_Init(PlayState* play, DynaSSNodeList* list);
-void DynaSSNodeList_Alloc(PlayState* play, DynaSSNodeList* list, u32 numNodes);
-void DynaSSNodeList_ResetCount(DynaSSNodeList* list);
-u16 DynaSSNodeList_GetNextNodeIdx(DynaSSNodeList* list);
-void BgCheck_Vec3sToVec3f(Vec3s* src, Vec3f* dest);
-void BgCheck_Vec3fToVec3s(Vec3s* dest, Vec3f* src);
-f32 func_800BFD84(CollisionPoly *poly, f32 arg1, f32 arg2);
-s32 func_800BFDEC(CollisionPoly* polyA, CollisionPoly* polyB, u32* outVtxId0, u32* outVtxId1);
-s16 CollisionPoly_GetMinY(CollisionPoly* poly, Vec3s* vertices);
-void CollisionPoly_GetNormalF(CollisionPoly* poly, f32* nx, f32* ny, f32* nz);
-void func_800C0094(CollisionPoly* poly, f32 tx, f32 ty, f32 tz, MtxF* dest);
-f32 CollisionPoly_GetPointDistanceFromPlane(CollisionPoly* poly, Vec3f* point);
-void CollisionPoly_GetVerticesByBgId(CollisionPoly* poly, s32 bgId, CollisionContext* colCtx, Vec3f* dest);
-s32 CollisionPoly_SphVsPoly(CollisionPoly* poly, Vec3s* vtxList, Vec3f* center, f32 radius);
-void StaticLookup_AddPolyToSSList(CollisionContext* colCtx, SSList* ssList, CollisionPoly* polyList, Vec3s* vtxList, s16 polyId);
-void StaticLookup_AddPoly(StaticLookup* lookup, CollisionContext* colCtx, CollisionPoly* polyList, Vec3s* vtxList, s16 index);
-void BgCheck_GetSubdivisionMinBounds(CollisionContext* colCtx, Vec3f* pos, s32* sx, s32* sy, s32* sz);
-void BgCheck_GetSubdivisionMaxBounds(CollisionContext* colCtx, Vec3f* pos, s32* sx, s32* sy, s32* sz);
-void BgCheck_GetPolySubdivisionBounds(CollisionContext* colCtx, Vec3s* vtxList, CollisionPoly* polyList, s32* subdivMinX, s32* subdivMinY, s32* subdivMinZ, s32* subdivMaxX, s32* subdivMaxY, s32* subdivMaxZ, s16 polyId);
-s32 BgCheck_PolyIntersectsSubdivision(Vec3f* min, Vec3f* max, CollisionPoly* polyList, Vec3s* vtxList, s16 polyId);
-u32 BgCheck_InitStaticLookup(CollisionContext* colCtx, PlayState* play, StaticLookup* lookupTbl);
-s32 BgCheck_IsSmallMemScene(PlayState* play);
-s32 BgCheck_TryGetCustomMemsize(s32 sceneId, u32* memSize);
-void BgCheck_SetSubdivisionDimension(f32 min, s32 subdivAmount, f32* max, f32* subdivLength, f32* subdivLengthInv);
-s32 BgCheck_GetSpecialSceneMaxObjects(PlayState* play, s32* maxNodes, s32* maxPolygons, s32* maxVertices);
-void BgCheck_Allocate(CollisionContext* colCtx, PlayState* play, CollisionHeader* colHeader);
-void BgCheck_SetContextFlags(CollisionContext* colCtx, u32 flags);
-void BgCheck_UnsetContextFlags(CollisionContext* colCtx, u32 flags);
-CollisionHeader* BgCheck_GetCollisionHeader(CollisionContext* colCtx, s32 bgId);
-f32 BgCheck_RaycastFloorImpl(PlayState* play, CollisionContext* colCtx, u16 xpFlags, CollisionPoly** outPoly, s32* outBgId, Vec3f* pos, Actor* actor, u32 arg7, f32 checkDist, s32 arg9);
-f32 BgCheck_CameraRaycastFloor1(CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor1(CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor2(PlayState* play, CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor2_1(PlayState* play, CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor3(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor5(CollisionContext* colCtx, CollisionPoly** outPoly, s32* outBgId, Actor* actor, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor5_2(PlayState* play, CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor5_3(PlayState* play, CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor6(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos, f32 checkDist);
-f32 BgCheck_EntityRaycastFloor7(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
-f32 BgCheck_AnyRaycastFloor1(CollisionContext* colCtx, CollisionPoly* outPoly, Vec3f* pos);
-f32 BgCheck_AnyRaycastFloor2(CollisionContext* colCtx, CollisionPoly* outPoly, s32* bgId, Vec3f* pos);
-f32 BgCheck_CameraRaycastFloor2(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor8(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
-f32 BgCheck_EntityRaycastFloor9(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
-s32 BgCheck_CheckWallImpl(CollisionContext* colCtx, u16 xpFlags, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight, u8 argA);
-s32 BgCheck_EntitySphVsWall1(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, f32 checkHeight);
-s32 BgCheck_EntitySphVsWall2(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, f32 checkHeight);
-s32 BgCheck_EntitySphVsWall3(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight);
-s32 BgCheck_EntitySphVsWall4(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight);
-s32 BgCheck_CheckCeilingImpl(CollisionContext* colCtx, u16 xpFlags, f32* outY, Vec3f* pos, f32 checkHeight, CollisionPoly** outPoly, s32* outBgId, Actor* actor);
-s32 BgCheck_AnyCheckCeiling(CollisionContext* colCtx, f32* outY, Vec3f* pos, f32 checkHeight);
-s32 BgCheck_EntityCheckCeiling(CollisionContext* colCtx, f32* outY, Vec3f* pos, f32 checkHeight, CollisionPoly** outPoly, s32* outBgId, Actor* actor);
-s32 BgCheck_CameraLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
-s32 BgCheck_CameraLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
-s32 BgCheck_EntityLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
-s32 BgCheck_EntityLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId, Actor* actor);
-s32 BgCheck_EntityLineTest3(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId, Actor* actor, f32 checkDist);
-s32 BgCheck_ProjectileLineTest(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
-s32 BgCheck_AnyLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkOneFace);
-s32 BgCheck_AnyLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace);
-s32 BgCheck_AnyLineTest3(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
-s32 BgCheck_SphVsFirstPolyImpl(CollisionContext* colCtx, u16 xpFlags, CollisionPoly** outPoly, s32* outBgId, Vec3f* center, f32 radius, Actor* actor, u16 bciFlags);
-s32 BgCheck_SphVsFirstPoly(CollisionContext* colCtx, Vec3f* center, f32 radius);
-s32 BgCheck_SphVsFirstWall(CollisionContext* colCtx, Vec3f* center, f32 radius);
-void SSNodeList_Init(SSNodeList* this);
-void SSNodeList_Alloc(PlayState* play, SSNodeList* this, s32 tblMax, s32 numPolys);
-SSNode* SSNodeList_GetNextNode(SSNodeList* this);
-u16 SSNodeList_GetNextNodeIdx(SSNodeList* this);
-void ScaleRotPos_Init(ScaleRotPos* srp);
-void ScaleRotPos_SetValue(ScaleRotPos* srp, Vec3f* scale, Vec3s* rot, Vec3f* pos);
-s32 ScaleRotPos_IsEqual(ScaleRotPos* a, ScaleRotPos* b);
-void DynaLookup_ResetLists(DynaLookup* dynaLookup);
-void DynaLookup_Reset(DynaLookup* dynaLookup);
-void DynaLookup_ResetVtxStartIndex(u16* vtxStartIndex);
-void DynaLookup_ResetWaterBoxStartIndex(u16* waterBoxStartIndex);
-void BgActor_Init(PlayState* play, BgActor* bgActor);
-void BgActor_SetActor(BgActor* bgActor, Actor* actor, CollisionHeader* colHeader);
-s32 BgActor_IsTransformUnchanged(BgActor* bgActor);
-void DynaPoly_NullPolyList(CollisionPoly** polyList);
-void DynaPoly_AllocPolyList(PlayState* play, CollisionPoly** polyList, s32 numPolys);
-void DynaPoly_NullVtxList(Vec3s** vtxList);
-void DynaPoly_AllocVtxList(PlayState* play, Vec3s** vtxList, s32 numVtx);
-void DynaPoly_InitWaterBoxList(DynaWaterBoxList* waterBoxList);
-void DynaPoly_AllocWaterBoxList(PlayState* play, DynaWaterBoxList* waterBoxList, s32 numWaterBoxes);
-void DynaPoly_SetBgActorPrevTransform(PlayState* play, BgActor* bgActor);
-s32 DynaPoly_IsBgIdBgActor(s32 bgId);
-void DynaPoly_Init(PlayState* play, DynaCollisionContext* dyna);
-void DynaPoly_Alloc(PlayState* play, DynaCollisionContext* dyna);
-s32 DynaPoly_SetBgActor(PlayState* play, DynaCollisionContext* dyna, Actor* actor, CollisionHeader* colHeader);
-DynaPolyActor* DynaPoly_GetActor(CollisionContext* colCtx, s32 bgId);
-void func_800C62BC(PlayState* play, DynaCollisionContext* dyna, s32 bgId);
-void func_800C6314(PlayState* play, DynaCollisionContext* dyna, s32 bgId);
-void func_800C636C(PlayState* play, DynaCollisionContext* dyna, s32 bgId);
-void func_800C63C4(PlayState* play, DynaCollisionContext* dyna, s32 bgId);
-void func_800C641C(PlayState* play, DynaCollisionContext* dyna, s32 bgId);
-void func_800C6474(PlayState* play, DynaCollisionContext* dyna, s32 bgId);
-void func_800C6554(PlayState* play, DynaCollisionContext* dyna);
-void DynaPoly_DeleteBgActor(PlayState* play, DynaCollisionContext* dyna, s32 bgId);
-void BgCheck_CalcWaterboxDimensions(Vec3f* minPos, Vec3f* maxXPos, Vec3f* maxZPos, Vec3s* minPosOut, s16* xLength, s16* zLength);
-void DynaPoly_ExpandSRT(PlayState* play, DynaCollisionContext* dyna, s32 bgId, s32* vtxStartIndex, s32* polyStartIndex, s32* waterBoxStartIndex);
-void BgCheck_ResetFlagsIfLoadedActor(PlayState* play, DynaCollisionContext* dyna, Actor* actor);
-void DynaPoly_Setup(PlayState* play, DynaCollisionContext* dyna);
-void func_800C756C(DynaCollisionContext* dyna, s32* numPolygons, s32* numVertices, s32* numWaterBoxes);
-void DynaPoly_UpdateBgActorTransforms(PlayState* play, DynaCollisionContext* dyna);
-void CollisionHeader_SegmentedToVirtual(CollisionHeader* colHeader);
-void CollisionHeader_GetVirtual(CollisionHeader* colHeader, CollisionHeader** dest);
-void BgCheck_InitCollisionHeaders(CollisionContext* colCtx, PlayState* play);
-
-u32 SurfaceType_GetBgCamIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u16 BgCheck_GetBgCamSettingImpl(CollisionContext* colCtx, u32 bgCamIndex, s32 bgId);
-u16 BgCheck_GetBgCamSetting(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u16 BgCheck_GetBgCamCountImpl(CollisionContext* colCtx, u32 bgCamIndex, s32 bgId);
-u16 BgCheck_GetBgCamCount(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-Vec3s* BgCheck_GetBgCamFuncDataImpl(CollisionContext* colCtx, s32 bgCamIndex, s32 bgId);
-Vec3s* BgCheck_GetBgCamFuncData(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-
-u32 SurfaceType_GetSceneExitIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 func_800C99D4(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 func_800C99FC(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 func_800C9A24(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 func_800C9A4C(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 func_800C9A7C(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 func_800C9AB0(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 func_800C9AE4(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 func_800C9B18(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 func_800C9B40(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 func_800C9B68(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 SurfaceType_IsHorseBlocked(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 func_800C9BB8(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u16 SurfaceType_GetSfx(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 func_800C9C24(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId, s32 arg3);
-u32 SurfaceType_GetSlope(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 SurfaceType_GetLightSettingIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 SurfaceType_GetEcho(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 SurfaceType_IsHookshotSurface(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 SurfaceType_IsIgnoredByEntities(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 SurfaceType_IsIgnoredByProjectiles(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 SurfaceType_IsFloorConveyor(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 func_800C9DDC(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 SurfaceType_GetConveyorSpeed(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 SurfaceType_GetConveyorDirection(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-u32 SurfaceType_IsWallDamage(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
-s32 WaterBox_GetSurfaceImpl(PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox, s32* bgId);
-s32 WaterBox_GetSurface1(PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
-s32 WaterBox_GetSurface1_2(PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
-s32 WaterBox_GetSurface2(PlayState* play, CollisionContext* colCtx, Vec3f* pos, f32 surfaceCheckDist, WaterBox** outWaterBox, s32* bgId);
-f32 func_800CA568(CollisionContext* colCtx, s32 waterBoxId, s32 bgId);
-u16 WaterBox_GetBgCamSetting(CollisionContext* colCtx, WaterBox* waterBox, s32 bgId);
-void WaterBox_GetSceneBgCamSetting(CollisionContext* colCtx, WaterBox* waterBox);
-u32 WaterBox_GetLightSettingIndex(CollisionContext* colCtx, WaterBox* waterBox);
-s32 func_800CA6F0(PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox, s32* bgId);
-s32 func_800CA9D0(PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
-s32 func_800CAA14(CollisionPoly* polyA, CollisionPoly* polyB, Vec3f* pointA, Vec3f* pointB, Vec3f* closestPoint);
 void BgCheck2_UpdateActorPosition(CollisionContext* colCtx, s32 bgId, Actor* actor);
 void BgCheck2_UpdateActorYRotation(CollisionContext* colCtx, s32 bgId, Actor* actor);
 void BgCheck2_AttachToMesh(CollisionContext* colCtx, Actor* actor, s32 bgId);
diff --git a/include/sfx.h b/include/sfx.h
index 33c79abf47..b55fbb357c 100644
--- a/include/sfx.h
+++ b/include/sfx.h
@@ -16,6 +16,8 @@
 #define SFX_FLAG_MASK 0xC00
 #define SFX_FLAG 0x800
 
+#define NA_SE_NONE 0
+
 // ------------ PLAYER ------------
 
 #define NA_SE_PL_WALK_GROUND 0x800
diff --git a/include/ultra64/thread.h b/include/ultra64/thread.h
index f3cd688907..62cbdcd1b0 100644
--- a/include/ultra64/thread.h
+++ b/include/ultra64/thread.h
@@ -54,16 +54,16 @@ typedef struct {
 } __OSThreadprofile; // size = 0x10
 
 typedef struct OSThread {
-    /*0x00*/ struct OSThread* next;
-    /*0x04*/ OSPri priority;
-    /*0x08*/ struct OSThread** queue;
-    /*0x0C*/ struct OSThread* tlnext;
-    /*0x10*/ u16 state;
-    /*0x12*/ u16 flags;
-    /*0x14*/ OSId id;
-    /*0x18*/ s32 fp;
-    /*0x1C*/ __OSThreadprofile* thprof;
-    /*0x20*/ __OSThreadContext context;
+    /* 0x00 */ struct OSThread* next;
+    /* 0x04 */ OSPri priority;
+    /* 0x08 */ struct OSThread** queue;
+    /* 0x0C */ struct OSThread* tlnext;
+    /* 0x10 */ u16 state;
+    /* 0x12 */ u16 flags;
+    /* 0x14 */ OSId id;
+    /* 0x18 */ s32 fp;
+    /* 0x1C */ __OSThreadprofile* thprof;
+    /* 0x20 */ __OSThreadContext context;
 } OSThread; // size = 0x1B0
 
 #endif
diff --git a/include/z64bgcheck.h b/include/z64bgcheck.h
index ad56599b5b..c6210b2c18 100644
--- a/include/z64bgcheck.h
+++ b/include/z64bgcheck.h
@@ -48,11 +48,6 @@ struct DynaPolyActor;
 #define COLPOLY_IGNORE_ENTITY (1 << 1)
 #define COLPOLY_IGNORE_PROJECTILES (1 << 2)
 
-// Surface Types
-#define COLPOLY_SURFACE_GROUND 0
-#define COLPOLY_SURFACE_SAND 1
-#define COLPOLY_SURFACE_SNOW 14
-
 // CollisionContext flags
 #define BGCHECK_FLAG_REVERSE_CONVEYOR_FLOW 1
 
@@ -114,6 +109,120 @@ typedef struct {
     // 0x0000_00FF = bgCam index
 } WaterBox; // size = 0x10
 
+typedef enum FloorType {
+    /*  0 */ FLOOR_TYPE_0,
+    /*  1 */ FLOOR_TYPE_1,
+    /*  2 */ FLOOR_TYPE_2,
+    /*  3 */ FLOOR_TYPE_3,
+    /*  4 */ FLOOR_TYPE_4,
+    /*  5 */ FLOOR_TYPE_5,
+    /*  6 */ FLOOR_TYPE_6,
+    /*  7 */ FLOOR_TYPE_7,
+    /*  8 */ FLOOR_TYPE_8,
+    /*  9 */ FLOOR_TYPE_9,
+    /* 10 */ FLOOR_TYPE_10,
+    /* 11 */ FLOOR_TYPE_11,
+    /* 12 */ FLOOR_TYPE_12,
+    /* 13 */ FLOOR_TYPE_13,
+    /* 14 */ FLOOR_TYPE_14,
+    /* 15 */ FLOOR_TYPE_15
+} FloorType;
+
+typedef enum WallType {
+    /*  0 */ WALL_TYPE_0,
+    /*  1 */ WALL_TYPE_1,
+    /*  2 */ WALL_TYPE_2,
+    /*  3 */ WALL_TYPE_3,
+    /*  4 */ WALL_TYPE_4,
+    /*  5 */ WALL_TYPE_5,
+    /*  6 */ WALL_TYPE_6,
+    /*  7 */ WALL_TYPE_7,
+    /*  8 */ WALL_TYPE_8,
+    /*  9 */ WALL_TYPE_9,
+    /* 10 */ WALL_TYPE_10,
+    /* 11 */ WALL_TYPE_11,
+    /* 12 */ WALL_TYPE_12,
+    /* 32 */ WALL_TYPE_MAX = 32
+} WallType;
+
+#define WALL_FLAG_0 (1 << 0)
+#define WALL_FLAG_1 (1 << 1)
+#define WALL_FLAG_2 (1 << 2)
+#define WALL_FLAG_3 (1 << 3)
+#define WALL_FLAG_4 (1 << 4)
+#define WALL_FLAG_5 (1 << 5)
+#define WALL_FLAG_6 (1 << 6)
+
+// SurfaceType can leave footsteps imprints in the material
+#define MATERIAL_PROPERTY_SOFT_IMPRINT (1 << 0)
+
+typedef enum FloorProperty {
+    /*  0 */ FLOOR_PROPERTY_0,
+    /*  1 */ FLOOR_PROPERTY_1,
+    /*  2 */ FLOOR_PROPERTY_2,
+    /*  5 */ FLOOR_PROPERTY_5 = 5,
+    /*  6 */ FLOOR_PROPERTY_6,
+    /*  7 */ FLOOR_PROPERTY_7,
+    /*  8 */ FLOOR_PROPERTY_8,
+    /*  9 */ FLOOR_PROPERTY_9,
+    /* 11 */ FLOOR_PROPERTY_11 = 11,
+    /* 12 */ FLOOR_PROPERTY_12,
+    /* 13 */ FLOOR_PROPERTY_13
+} FloorProperty;
+
+typedef enum SurfaceSfxOffset {
+    /*  0 */ SURFACE_SFX_OFFSET_DIRT,
+    /*  1 */ SURFACE_SFX_OFFSET_SAND,
+    /*  2 */ SURFACE_SFX_OFFSET_STONE,
+    /*  3 */ SURFACE_SFX_OFFSET_DIRT_SHALLOW,
+    /*  4 */ SURFACE_SFX_OFFSET_WATER_SHALLOW,
+    /*  5 */ SURFACE_SFX_OFFSET_WATER_DEEP,
+    /*  6 */ SURFACE_SFX_OFFSET_TALL_GRASS,
+    /*  7 */ SURFACE_SFX_OFFSET_LAVA, // MAGMA?
+    /*  8 */ SURFACE_SFX_OFFSET_GRASS,
+    /*  9 */ SURFACE_SFX_OFFSET_CARPET,
+    /* 10 */ SURFACE_SFX_OFFSET_WOOD,
+    /* 11 */ SURFACE_SFX_OFFSET_BRIDGE, // WOOD_PLANK?
+    /* 12 */ SURFACE_SFX_OFFSET_VINE, // METAL?
+    /* 13 */ SURFACE_SFX_OFFSET_DIRT_DEEP,
+    /* 14 */ SURFACE_SFX_OFFSET_SNOW,
+    /* 15 */ SURFACE_SFX_OFFSET_ICE
+} SurfaceSfxOffset;
+
+typedef enum SurfaceMaterial {
+    /*  0 */ SURFACE_MATERIAL_DIRT,
+    /*  1 */ SURFACE_MATERIAL_SAND,
+    /*  2 */ SURFACE_MATERIAL_STONE,
+    /*  3 */ SURFACE_MATERIAL_DIRT_SHALLOW,
+    /*  4 */ SURFACE_MATERIAL_WATER_SHALLOW,
+    /*  5 */ SURFACE_MATERIAL_WATER_DEEP,
+    /*  6 */ SURFACE_MATERIAL_TALL_GRASS,
+    /*  7 */ SURFACE_MATERIAL_LAVA, // MAGMA?
+    /*  8 */ SURFACE_MATERIAL_GRASS,
+    /*  9 */ SURFACE_MATERIAL_BRIDGE, // WOOD_PLANK?
+    /* 10 */ SURFACE_MATERIAL_WOOD,
+    /* 11 */ SURFACE_MATERIAL_DIRT_SOFT,
+    /* 12 */ SURFACE_MATERIAL_ICE,
+    /* 13 */ SURFACE_MATERIAL_CARPET,
+    /* 14 */ SURFACE_MATERIAL_SNOW,
+    /* 15 */ SURFACE_MATERIAL_MAX
+} SurfaceMaterial;
+
+typedef enum FloorEffect {
+    /* 0 */ FLOOR_EFFECT_0,
+    /* 1 */ FLOOR_EFFECT_1,
+    /* 2 */ FLOOR_EFFECT_2,
+    /* 3 */ FLOOR_EFFECT_3
+} FloorEffect;
+
+typedef enum ConveyorSpeed {
+    /* 0 */ CONVEYOR_SPEED_DISABLED,
+    /* 1 */ CONVEYOR_SPEED_SLOW,
+    /* 2 */ CONVEYOR_SPEED_MEDIUM,
+    /* 3 */ CONVEYOR_SPEED_FAST,
+    /* 4 */ CONVEYOR_SPEED_MAX
+} ConveyorSpeed;
+
 typedef struct {
     /* 0x0 */ u32 data[2];
 
@@ -219,14 +328,14 @@ typedef struct {
 } DynaCollisionContext; // size = 0x1418
 
 typedef struct {
-    /* 0x00 */ CollisionHeader* colHeader; // scene's static collision
-    /* 0x04 */ Vec3f minBounds;            // minimum coordinates of collision bounding box
-    /* 0x10 */ Vec3f maxBounds;            // maximum coordinates of collision bounding box
-    /* 0x1C */ Vec3i subdivAmount;         // x, y, z subdivisions of the scene's static collision
-    /* 0x28 */ Vec3f subdivLength;         // x, y, z subdivision worldspace lengths
-    /* 0x34 */ Vec3f subdivLengthInv;      // inverse of subdivision length
-    /* 0x40 */ StaticLookup* lookupTbl;    // 3d array of length subdivAmount
-    /* 0x44 */ SSNodeList polyNodes;
+    /* 0x0000 */ CollisionHeader* colHeader; // scene's static collision
+    /* 0x0004 */ Vec3f minBounds;            // minimum coordinates of collision bounding box
+    /* 0x0010 */ Vec3f maxBounds;            // maximum coordinates of collision bounding box
+    /* 0x001C */ Vec3i subdivAmount;         // x, y, z subdivisions of the scene's static collision
+    /* 0x0028 */ Vec3f subdivLength;         // x, y, z subdivision worldspace lengths
+    /* 0x0034 */ Vec3f subdivLengthInv;      // inverse of subdivision length
+    /* 0x0040 */ StaticLookup* lookupTbl;    // 3d array of length subdivAmount
+    /* 0x0044 */ SSNodeList polyNodes;
     /* 0x0050 */ DynaCollisionContext dyna;
     /* 0x1468 */ u32 memSize; // Size of all allocated memory plus CollisionContext
     /* 0x146C */ u32 flags;   // bit 0 reverses conveyor direction (i.e. water flow in Great Bay Temple)
@@ -317,4 +426,162 @@ typedef struct {
     /* 0x8 */ s32 nodeListMax; // if -1, dynamically compute max nodes
 } BgCheckSceneSubdivisionEntry; // size = 0xC
 
+void SSNode_SetValue(SSNode* node, s16* polyIndex, u16 next);
+void SSList_SetNull(SSList* ssList);
+void SSNodeList_SetSSListHead(SSNodeList* list, SSList* ssList, s16* polyIndex);
+void DynaSSNodeList_SetSSListHead(DynaSSNodeList* list, SSList* ssList, s16* polyIndex);
+void DynaSSNodeList_Init(struct PlayState* play, DynaSSNodeList* list);
+void DynaSSNodeList_Alloc(struct PlayState* play, DynaSSNodeList* list, u32 numNodes);
+void DynaSSNodeList_ResetCount(DynaSSNodeList* list);
+u16 DynaSSNodeList_GetNextNodeIdx(DynaSSNodeList* list);
+void BgCheck_Vec3sToVec3f(Vec3s* src, Vec3f* dest);
+void BgCheck_Vec3fToVec3s(Vec3s* dest, Vec3f* src);
+f32 func_800BFD84(CollisionPoly *poly, f32 arg1, f32 arg2);
+s32 func_800BFDEC(CollisionPoly* polyA, CollisionPoly* polyB, u32* outVtxId0, u32* outVtxId1);
+s16 CollisionPoly_GetMinY(CollisionPoly* poly, Vec3s* vertices);
+void CollisionPoly_GetNormalF(CollisionPoly* poly, f32* nx, f32* ny, f32* nz);
+void func_800C0094(CollisionPoly* poly, f32 tx, f32 ty, f32 tz, MtxF* dest);
+f32 CollisionPoly_GetPointDistanceFromPlane(CollisionPoly* poly, Vec3f* point);
+void CollisionPoly_GetVerticesByBgId(CollisionPoly* poly, s32 bgId, CollisionContext* colCtx, Vec3f* dest);
+s32 CollisionPoly_SphVsPoly(CollisionPoly* poly, Vec3s* vtxList, Vec3f* center, f32 radius);
+void StaticLookup_AddPolyToSSList(CollisionContext* colCtx, SSList* ssList, CollisionPoly* polyList, Vec3s* vtxList, s16 polyId);
+void StaticLookup_AddPoly(StaticLookup* lookup, CollisionContext* colCtx, CollisionPoly* polyList, Vec3s* vtxList, s16 index);
+void BgCheck_GetSubdivisionMinBounds(CollisionContext* colCtx, Vec3f* pos, s32* sx, s32* sy, s32* sz);
+void BgCheck_GetSubdivisionMaxBounds(CollisionContext* colCtx, Vec3f* pos, s32* sx, s32* sy, s32* sz);
+void BgCheck_GetPolySubdivisionBounds(CollisionContext* colCtx, Vec3s* vtxList, CollisionPoly* polyList, s32* subdivMinX, s32* subdivMinY, s32* subdivMinZ, s32* subdivMaxX, s32* subdivMaxY, s32* subdivMaxZ, s16 polyId);
+s32 BgCheck_PolyIntersectsSubdivision(Vec3f* min, Vec3f* max, CollisionPoly* polyList, Vec3s* vtxList, s16 polyId);
+u32 BgCheck_InitStaticLookup(CollisionContext* colCtx, struct PlayState* play, StaticLookup* lookupTbl);
+s32 BgCheck_IsSmallMemScene(struct PlayState* play);
+s32 BgCheck_TryGetCustomMemsize(s32 sceneId, u32* memSize);
+void BgCheck_SetSubdivisionDimension(f32 min, s32 subdivAmount, f32* max, f32* subdivLength, f32* subdivLengthInv);
+s32 BgCheck_GetSpecialSceneMaxObjects(struct PlayState* play, s32* maxNodes, s32* maxPolygons, s32* maxVertices);
+void BgCheck_Allocate(CollisionContext* colCtx, struct PlayState* play, CollisionHeader* colHeader);
+void BgCheck_SetContextFlags(CollisionContext* colCtx, u32 flags);
+void BgCheck_UnsetContextFlags(CollisionContext* colCtx, u32 flags);
+CollisionHeader* BgCheck_GetCollisionHeader(CollisionContext* colCtx, s32 bgId);
+f32 BgCheck_RaycastFloorImpl(struct PlayState* play, CollisionContext* colCtx, u16 xpFlags, CollisionPoly** outPoly, s32* outBgId, Vec3f* pos, Actor* actor, u32 arg7, f32 checkDist, s32 arg9);
+f32 BgCheck_CameraRaycastFloor1(CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor1(CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor2(struct PlayState* play, CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor2_1(struct PlayState* play, CollisionContext* colCtx, CollisionPoly** outPoly, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor3(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor5(CollisionContext* colCtx, CollisionPoly** outPoly, s32* outBgId, Actor* actor, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor5_2(struct PlayState* play, CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor5_3(struct PlayState* play, CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor6(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos, f32 checkDist);
+f32 BgCheck_EntityRaycastFloor7(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
+f32 BgCheck_AnyRaycastFloor1(CollisionContext* colCtx, CollisionPoly* outPoly, Vec3f* pos);
+f32 BgCheck_AnyRaycastFloor2(CollisionContext* colCtx, CollisionPoly* outPoly, s32* bgId, Vec3f* pos);
+f32 BgCheck_CameraRaycastFloor2(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor8(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Actor* actor, Vec3f* pos);
+f32 BgCheck_EntityRaycastFloor9(CollisionContext* colCtx, CollisionPoly** outPoly, s32* bgId, Vec3f* pos);
+s32 BgCheck_CheckWallImpl(CollisionContext* colCtx, u16 xpFlags, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight, u8 argA);
+s32 BgCheck_EntitySphVsWall1(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, f32 checkHeight);
+s32 BgCheck_EntitySphVsWall2(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, f32 checkHeight);
+s32 BgCheck_EntitySphVsWall3(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight);
+s32 BgCheck_EntitySphVsWall4(CollisionContext* colCtx, Vec3f* posResult, Vec3f* posNext, Vec3f* posPrev, f32 radius, CollisionPoly** outPoly, s32* outBgId, Actor* actor, f32 checkHeight);
+s32 BgCheck_CheckCeilingImpl(CollisionContext* colCtx, u16 xpFlags, f32* outY, Vec3f* pos, f32 checkHeight, CollisionPoly** outPoly, s32* outBgId, Actor* actor);
+s32 BgCheck_AnyCheckCeiling(CollisionContext* colCtx, f32* outY, Vec3f* pos, f32 checkHeight);
+s32 BgCheck_EntityCheckCeiling(CollisionContext* colCtx, f32* outY, Vec3f* pos, f32 checkHeight, CollisionPoly** outPoly, s32* outBgId, Actor* actor);
+s32 BgCheck_CameraLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
+s32 BgCheck_CameraLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
+s32 BgCheck_EntityLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
+s32 BgCheck_EntityLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId, Actor* actor);
+s32 BgCheck_EntityLineTest3(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId, Actor* actor, f32 checkDist);
+s32 BgCheck_ProjectileLineTest(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
+s32 BgCheck_AnyLineTest1(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkOneFace);
+s32 BgCheck_AnyLineTest2(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace);
+s32 BgCheck_AnyLineTest3(CollisionContext* colCtx, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** outPoly, s32 checkWall, s32 checkFloor, s32 checkCeil, s32 checkOneFace, s32* bgId);
+s32 BgCheck_SphVsFirstPolyImpl(CollisionContext* colCtx, u16 xpFlags, CollisionPoly** outPoly, s32* outBgId, Vec3f* center, f32 radius, Actor* actor, u16 bciFlags);
+s32 BgCheck_SphVsFirstPoly(CollisionContext* colCtx, Vec3f* center, f32 radius);
+s32 BgCheck_SphVsFirstWall(CollisionContext* colCtx, Vec3f* center, f32 radius);
+void SSNodeList_Init(SSNodeList* this);
+void SSNodeList_Alloc(struct PlayState* play, SSNodeList* this, s32 tblMax, s32 numPolys);
+SSNode* SSNodeList_GetNextNode(SSNodeList* this);
+u16 SSNodeList_GetNextNodeIdx(SSNodeList* this);
+void ScaleRotPos_Init(ScaleRotPos* srp);
+void ScaleRotPos_SetValue(ScaleRotPos* srp, Vec3f* scale, Vec3s* rot, Vec3f* pos);
+s32 ScaleRotPos_IsEqual(ScaleRotPos* a, ScaleRotPos* b);
+void DynaLookup_ResetLists(DynaLookup* dynaLookup);
+void DynaLookup_Reset(DynaLookup* dynaLookup);
+void DynaLookup_ResetVtxStartIndex(u16* vtxStartIndex);
+void DynaLookup_ResetWaterBoxStartIndex(u16* waterBoxStartIndex);
+void BgActor_Init(struct PlayState* play, BgActor* bgActor);
+void BgActor_SetActor(BgActor* bgActor, Actor* actor, CollisionHeader* colHeader);
+s32 BgActor_IsTransformUnchanged(BgActor* bgActor);
+void DynaPoly_NullPolyList(CollisionPoly** polyList);
+void DynaPoly_AllocPolyList(struct PlayState* play, CollisionPoly** polyList, s32 numPolys);
+void DynaPoly_NullVtxList(Vec3s** vtxList);
+void DynaPoly_AllocVtxList(struct PlayState* play, Vec3s** vtxList, s32 numVtx);
+void DynaPoly_InitWaterBoxList(DynaWaterBoxList* waterBoxList);
+void DynaPoly_AllocWaterBoxList(struct PlayState* play, DynaWaterBoxList* waterBoxList, s32 numWaterBoxes);
+void DynaPoly_SetBgActorPrevTransform(struct PlayState* play, BgActor* bgActor);
+s32 DynaPoly_IsBgIdBgActor(s32 bgId);
+void DynaPoly_Init(struct PlayState* play, DynaCollisionContext* dyna);
+void DynaPoly_Alloc(struct PlayState* play, DynaCollisionContext* dyna);
+s32 DynaPoly_SetBgActor(struct PlayState* play, DynaCollisionContext* dyna, Actor* actor, CollisionHeader* colHeader);
+DynaPolyActor* DynaPoly_GetActor(CollisionContext* colCtx, s32 bgId);
+void func_800C62BC(struct PlayState* play, DynaCollisionContext* dyna, s32 bgId);
+void func_800C6314(struct PlayState* play, DynaCollisionContext* dyna, s32 bgId);
+void func_800C636C(struct PlayState* play, DynaCollisionContext* dyna, s32 bgId);
+void func_800C63C4(struct PlayState* play, DynaCollisionContext* dyna, s32 bgId);
+void func_800C641C(struct PlayState* play, DynaCollisionContext* dyna, s32 bgId);
+void func_800C6474(struct PlayState* play, DynaCollisionContext* dyna, s32 bgId);
+void func_800C6554(struct PlayState* play, DynaCollisionContext* dyna);
+void DynaPoly_DeleteBgActor(struct PlayState* play, DynaCollisionContext* dyna, s32 bgId);
+void BgCheck_CalcWaterboxDimensions(Vec3f* minPos, Vec3f* maxXPos, Vec3f* maxZPos, Vec3s* minPosOut, s16* xLength, s16* zLength);
+void DynaPoly_ExpandSRT(struct PlayState* play, DynaCollisionContext* dyna, s32 bgId, s32* vtxStartIndex, s32* polyStartIndex, s32* waterBoxStartIndex);
+void BgCheck_ResetFlagsIfLoadedActor(struct PlayState* play, DynaCollisionContext* dyna, Actor* actor);
+void DynaPoly_Setup(struct PlayState* play, DynaCollisionContext* dyna);
+void func_800C756C(DynaCollisionContext* dyna, s32* numPolygons, s32* numVertices, s32* numWaterBoxes);
+void DynaPoly_UpdateBgActorTransforms(struct PlayState* play, DynaCollisionContext* dyna);
+void CollisionHeader_SegmentedToVirtual(CollisionHeader* colHeader);
+void CollisionHeader_GetVirtual(CollisionHeader* colHeader, CollisionHeader** dest);
+void BgCheck_InitCollisionHeaders(CollisionContext* colCtx, struct PlayState* play);
+
+u32 SurfaceType_GetBgCamIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u16 BgCheck_GetBgCamSettingImpl(CollisionContext* colCtx, u32 bgCamIndex, s32 bgId);
+u16 BgCheck_GetBgCamSetting(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u16 BgCheck_GetBgCamCountImpl(CollisionContext* colCtx, u32 bgCamIndex, s32 bgId);
+u16 BgCheck_GetBgCamCount(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+Vec3s* BgCheck_GetBgCamFuncDataImpl(CollisionContext* colCtx, s32 bgCamIndex, s32 bgId);
+Vec3s* BgCheck_GetBgCamFuncData(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+
+u32 SurfaceType_GetSceneExitIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+FloorType SurfaceType_GetFloorType(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u32 func_800C99FC(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 SurfaceType_GetWallFlags(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 SurfaceType_CheckWallFlag0(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 SurfaceType_CheckWallFlag1(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 SurfaceType_CheckWallFlag2(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+FloorProperty SurfaceType_GetFloorProperty2(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+FloorProperty SurfaceType_GetFloorProperty(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u32 SurfaceType_IsSoft(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u32 SurfaceType_IsHorseBlocked(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+SurfaceMaterial SurfaceType_GetMaterial(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u16 SurfaceType_GetSfxOffset(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 SurfaceType_HasMaterialProperty(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId, s32 propertyType);
+FloorEffect SurfaceType_GetFloorEffect(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u32 SurfaceType_GetLightSettingIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u32 SurfaceType_GetEcho(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u32 SurfaceType_IsHookshotSurface(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 SurfaceType_IsIgnoredByEntities(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 SurfaceType_IsIgnoredByProjectiles(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 SurfaceType_IsFloorConveyor(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 func_800C9DDC(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+ConveyorSpeed SurfaceType_GetConveyorSpeed(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u32 SurfaceType_GetConveyorDirection(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+u32 SurfaceType_IsWallDamage(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId);
+s32 WaterBox_GetSurfaceImpl(struct PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox, s32* bgId);
+s32 WaterBox_GetSurface1(struct PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
+s32 WaterBox_GetSurface1_2(struct PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
+s32 WaterBox_GetSurface2(struct PlayState* play, CollisionContext* colCtx, Vec3f* pos, f32 surfaceCheckDist, WaterBox** outWaterBox, s32* bgId);
+f32 func_800CA568(CollisionContext* colCtx, s32 waterBoxId, s32 bgId);
+u16 WaterBox_GetBgCamSetting(CollisionContext* colCtx, WaterBox* waterBox, s32 bgId);
+void WaterBox_GetSceneBgCamSetting(CollisionContext* colCtx, WaterBox* waterBox);
+u32 WaterBox_GetLightSettingIndex(CollisionContext* colCtx, WaterBox* waterBox);
+s32 func_800CA6F0(struct PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox, s32* bgId);
+s32 func_800CA9D0(struct PlayState* play, CollisionContext* colCtx, f32 x, f32 z, f32* ySurface, WaterBox** outWaterBox);
+s32 func_800CAA14(CollisionPoly* polyA, CollisionPoly* polyB, Vec3f* pointA, Vec3f* pointB, Vec3f* closestPoint);
+
 #endif
diff --git a/src/boot_O2_g3/fault.c b/src/boot_O2_g3/fault.c
index 5e4f8e24a9..2c8f4a6679 100644
--- a/src/boot_O2_g3/fault.c
+++ b/src/boot_O2_g3/fault.c
@@ -802,8 +802,8 @@ void Fault_ThreadEntry(void* arg) {
     u32 pad;
     OSThread* faultedThread;
 
-    osSetEventMesg(10, &sFaultContext->queue, (OSMesg)1);
-    osSetEventMesg(12, &sFaultContext->queue, (OSMesg)2);
+    osSetEventMesg(OS_EVENT_CPU_BREAK, &sFaultContext->queue, (OSMesg)1);
+    osSetEventMesg(OS_EVENT_FAULT, &sFaultContext->queue, (OSMesg)2);
     while (1) {
         do {
             osRecvMesg(&sFaultContext->queue, &msg, OS_MESG_BLOCK);
diff --git a/src/boot_O2_g3/irqmgr.c b/src/boot_O2_g3/irqmgr.c
index 424451a5b0..1f1e94ab40 100644
--- a/src/boot_O2_g3/irqmgr.c
+++ b/src/boot_O2_g3/irqmgr.c
@@ -161,7 +161,7 @@ void IrqMgr_Init(IrqMgr* irqmgr, void* stack, OSPri pri, u8 retraceCount) {
     irqmgr->lastPrenmiTime = 0;
 
     osCreateMesgQueue(&irqmgr->irqQueue, (OSMesg*)irqmgr->irqBuffer, ARRAY_COUNT(irqmgr->irqBuffer));
-    osSetEventMesg(0xE, &irqmgr->irqQueue, (OSMesg)0x29D);
+    osSetEventMesg(OS_EVENT_PRENMI, &irqmgr->irqQueue, (OSMesg)0x29D);
     osViSetEvent(&irqmgr->irqQueue, (OSMesg)0x29A, retraceCount);
 
     osCreateThread(&irqmgr->thread, Z_THREAD_ID_IRQMGR, IrqMgr_ThreadEntry, irqmgr, stack, pri);
diff --git a/src/boot_O2_g3/z_std_dma.c b/src/boot_O2_g3/z_std_dma.c
index 00d894f74a..bbf8e4bed4 100644
--- a/src/boot_O2_g3/z_std_dma.c
+++ b/src/boot_O2_g3/z_std_dma.c
@@ -1,4 +1,3 @@
-#include "prevent_bss_reordering.h"
 #include "global.h"
 #include "stack.h"
 #include "stackcheck.h"
diff --git a/src/code/sched.c b/src/code/sched.c
index c2630677cd..98b005ba10 100644
--- a/src/code/sched.c
+++ b/src/code/sched.c
@@ -1,4 +1,3 @@
-#include "prevent_bss_reordering.h"
 #include "global.h"
 #include "stackcheck.h"
 
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index db01bb3451..b58f6700aa 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -234,8 +234,9 @@ void ActorShadow_DrawFeet(Actor* actor, Lights* mapper, PlayState* play) {
                 if (distToFloor <= 10.0f) {
                     actor->shape.feetFloorFlags |= spB8;
 
-                    if ((actor->depthInWater < 0.0f) && (bgId == 0x32) && ((actor->shape.unk_17 & spB8) != 0)) {
-                        if (func_800C9C24(&play->colCtx, poly, bgId, 1)) {
+                    if ((actor->depthInWater < 0.0f) && (bgId == BGCHECK_SCENE) && (actor->shape.unk_17 & spB8)) {
+                        if (SurfaceType_HasMaterialProperty(&play->colCtx, poly, bgId,
+                                                            MATERIAL_PROPERTY_SOFT_IMPRINT)) {
                             SkinMatrix_MtxFCopy(&sp13C, &spFC);
                             SkinMatrix_MulYRotation(&spFC, actor->shape.rot.y);
                             EffFootmark_Add(play, &spFC, actor, i, feetPosPtr, (actor->shape.shadowScale * 0.3f),
@@ -2183,20 +2184,20 @@ void Actor_PlaySfx(Actor* actor, u16 sfxId) {
 }
 
 void func_800B8EF4(PlayState* play, Actor* actor) {
-    u32 sfxId;
+    SurfaceSfxOffset surfaceSfxOffset;
 
     if (actor->bgCheckFlags & BGCHECKFLAG_WATER) {
         if (actor->depthInWater < 20.0f) {
-            sfxId = NA_SE_PL_WALK_WATER0 - SFX_FLAG;
+            surfaceSfxOffset = SURFACE_SFX_OFFSET_WATER_SHALLOW;
         } else {
-            sfxId = NA_SE_PL_WALK_WATER1 - SFX_FLAG;
+            surfaceSfxOffset = SURFACE_SFX_OFFSET_WATER_DEEP;
         }
     } else {
-        sfxId = SurfaceType_GetSfx(&play->colCtx, actor->floorPoly, actor->floorBgId);
+        surfaceSfxOffset = SurfaceType_GetSfxOffset(&play->colCtx, actor->floorPoly, actor->floorBgId);
     }
 
     Audio_PlaySfxAtPos(&actor->projectedPos, NA_SE_EV_BOMB_BOUND);
-    Audio_PlaySfxAtPos(&actor->projectedPos, sfxId + SFX_FLAG);
+    Audio_PlaySfxAtPos(&actor->projectedPos, NA_SE_PL_WALK_GROUND + surfaceSfxOffset);
 }
 
 void func_800B8F98(Actor* actor, u16 sfxId) {
@@ -2248,7 +2249,7 @@ void func_800B9098(Actor* actor) {
 }
 
 s32 func_800B90AC(PlayState* play, Actor* actor, CollisionPoly* polygon, s32 bgId, Vec3f* arg4) {
-    if (func_800C99D4(&play->colCtx, polygon, bgId) == 8) {
+    if (SurfaceType_GetFloorType(&play->colCtx, polygon, bgId) == FLOOR_TYPE_8) {
         return true;
     }
 
diff --git a/src/code/z_bgcheck.c b/src/code/z_bgcheck.c
index c0bfe80470..de0d5d12a3 100644
--- a/src/code/z_bgcheck.c
+++ b/src/code/z_bgcheck.c
@@ -6,44 +6,51 @@
 #define DYNA_RAYCAST_WALLS 2
 #define DYNA_RAYCAST_CEILINGS 4
 
-u32 sWallFlags[32] = {
-    0, 1, 3, 5, 8, 16, 32, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+u32 sWallFlags[WALL_TYPE_MAX] = {
+    0,                         // WALL_TYPE_0
+    WALL_FLAG_0,               // WALL_TYPE_1
+    WALL_FLAG_0 | WALL_FLAG_1, // WALL_TYPE_2
+    WALL_FLAG_0 | WALL_FLAG_2, // WALL_TYPE_3
+    WALL_FLAG_3,               // WALL_TYPE_4
+    WALL_FLAG_4,               // WALL_TYPE_5
+    WALL_FLAG_5,               // WALL_TYPE_6
+    WALL_FLAG_6,               // WALL_TYPE_7
 };
 
-u16 sSurfaceTypeSfx[] = {
-    /* 0x00 */ NA_SE_PL_WALK_GROUND - SFX_FLAG,
-    /* 0x01 */ NA_SE_PL_WALK_SAND - SFX_FLAG,
-    /* 0x02 */ NA_SE_PL_WALK_CONCRETE - SFX_FLAG,
-    /* 0x03 */ NA_SE_PL_WALK_DIRT - SFX_FLAG,
-    /* 0x04 */ NA_SE_PL_WALK_WATER0 - SFX_FLAG,
-    /* 0x05 */ NA_SE_PL_WALK_WATER1 - SFX_FLAG,
-    /* 0x06 */ NA_SE_PL_WALK_WATER2 - SFX_FLAG,
-    /* 0x07 */ NA_SE_PL_WALK_MAGMA - SFX_FLAG,
-    /* 0x08 */ NA_SE_PL_WALK_GRASS - SFX_FLAG,
-    /* 0x09 */ NA_SE_PL_WALK_GLASS - SFX_FLAG,
-    /* 0x0A */ NA_SE_PL_WALK_LADDER - SFX_FLAG,
-    /* 0x0B */ NA_SE_PL_WALK_GROUND - SFX_FLAG,
-    /* 0x0C */ NA_SE_PL_WALK_ICE - SFX_FLAG,
-    /* 0x0D */ NA_SE_PL_WALK_IRON - SFX_FLAG,
-    /* 0x0E */ NA_SE_PL_WALK_SNOW - SFX_FLAG
+u16 sSurfaceSfxOffsets[SURFACE_MATERIAL_MAX] = {
+    SURFACE_SFX_OFFSET_DIRT,          // SURFACE_MATERIAL_DIRT
+    SURFACE_SFX_OFFSET_SAND,          // SURFACE_MATERIAL_SAND
+    SURFACE_SFX_OFFSET_STONE,         // SURFACE_MATERIAL_STONE
+    SURFACE_SFX_OFFSET_DIRT_SHALLOW,  // SURFACE_MATERIAL_DIRT_SHALLOW
+    SURFACE_SFX_OFFSET_WATER_SHALLOW, // SURFACE_MATERIAL_WATER_SHALLOW
+    SURFACE_SFX_OFFSET_WATER_DEEP,    // SURFACE_MATERIAL_WATER_DEEP
+    SURFACE_SFX_OFFSET_TALL_GRASS,    // SURFACE_MATERIAL_TALL_GRASS
+    SURFACE_SFX_OFFSET_LAVA,          // SURFACE_MATERIAL_LAVA
+    SURFACE_SFX_OFFSET_GRASS,         // SURFACE_MATERIAL_GRASS
+    SURFACE_SFX_OFFSET_BRIDGE,        // SURFACE_MATERIAL_BRIDGE
+    SURFACE_SFX_OFFSET_WOOD,          // SURFACE_MATERIAL_WOOD
+    SURFACE_SFX_OFFSET_DIRT,          // SURFACE_MATERIAL_DIRT_SOFT
+    SURFACE_SFX_OFFSET_ICE,           // SURFACE_MATERIAL_ICE
+    SURFACE_SFX_OFFSET_CARPET,        // SURFACE_MATERIAL_CARPET
+    SURFACE_SFX_OFFSET_SNOW,          // SURFACE_MATERIAL_SNOW
 };
 
-u8 D_801B46C0[] = {
-    /* 0x00 */ 1,
-    /* 0x01 */ 1,
-    /* 0x02 */ 0,
-    /* 0x03 */ 1,
-    /* 0x04 */ 0,
-    /* 0x05 */ 0,
-    /* 0x06 */ 0,
-    /* 0x07 */ 0,
-    /* 0x08 */ 0,
-    /* 0x09 */ 0,
-    /* 0x0A */ 0,
-    /* 0x0B */ 0,
-    /* 0x0C */ 0,
-    /* 0x0D */ 0,
-    /* 0x0E */ 1
+u8 sSurfaceMaterialProperties[SURFACE_MATERIAL_MAX] = {
+    MATERIAL_PROPERTY_SOFT_IMPRINT, // SURFACE_MATERIAL_DIRT
+    MATERIAL_PROPERTY_SOFT_IMPRINT, // SURFACE_MATERIAL_SAND
+    0,                              // SURFACE_MATERIAL_STONE
+    MATERIAL_PROPERTY_SOFT_IMPRINT, // SURFACE_MATERIAL_DIRT_SHALLOW
+    0,                              // SURFACE_MATERIAL_WATER_SHALLOW
+    0,                              // SURFACE_MATERIAL_WATER_DEEP
+    0,                              // SURFACE_MATERIAL_TALL_GRASS
+    0,                              // SURFACE_MATERIAL_LAVA
+    0,                              // SURFACE_MATERIAL_GRASS
+    0,                              // SURFACE_MATERIAL_BRIDGE
+    0,                              // SURFACE_MATERIAL_WOOD
+    0,                              // SURFACE_MATERIAL_DIRT_SOFT
+    0,                              // SURFACE_MATERIAL_ICE
+    0,                              // SURFACE_MATERIAL_CARPET
+    MATERIAL_PROPERTY_SOFT_IMPRINT, // SURFACE_MATERIAL_SNOW
 };
 
 s16 sSmallMemSceneIds[] = {
@@ -51,9 +58,9 @@ s16 sSmallMemSceneIds[] = {
 };
 
 typedef struct {
-    s16 sceneId;
-    u32 memSize;
-} BgCheckSceneMemEntry;
+    /* 0x0 */ s16 sceneId;
+    /* 0x4 */ u32 memSize;
+} BgCheckSceneMemEntry; // size = 0x8
 
 BgCheckSceneMemEntry sSceneMemList[] = {
     { SCENE_00KEIKOKU, 0xC800 },
@@ -1734,7 +1741,7 @@ f32 BgCheck_RaycastFloorImpl(PlayState* play, CollisionContext* colCtx, u16 xpFl
         }
     }
 
-    if ((yIntersect != BGCHECK_Y_MIN) && func_800C9B68(colCtx, *outPoly, *outBgId)) {
+    if ((yIntersect != BGCHECK_Y_MIN) && SurfaceType_IsSoft(colCtx, *outPoly, *outBgId)) {
         yIntersect -= 1.0f;
     }
     return yIntersect;
@@ -3204,7 +3211,8 @@ f32 BgCheck_RaycastFloorDynaList(DynaRaycast* dynaRaycast, u32 listType) {
             (COLPOLY_VIA_FLAG_TEST(polyList[id].flags_vIB, 4) &&
              (((dynaRaycast->actor != NULL) && (dynaRaycast->actor->category != ACTORCAT_PLAYER)) ||
               ((dynaRaycast->actor == NULL) && (dynaRaycast->xpFlags != COLPOLY_IGNORE_CAMERA)))) ||
-            ((dynaRaycast->unk_24 & 0x20) && func_800C9B68(dynaRaycast->colCtx, &polyList[id], dynaRaycast->unk1C))) {
+            ((dynaRaycast->unk_24 & 0x20) &&
+             SurfaceType_IsSoft(dynaRaycast->colCtx, &polyList[id], dynaRaycast->unk1C))) {
             if (curNode->next == SS_NULL) {
                 break;
             } else {
@@ -4187,17 +4195,11 @@ Vec3s* BgCheck_GetBgCamFuncData(CollisionContext* colCtx, CollisionPoly* poly, s
     return BgCheck_GetBgCamFuncDataImpl(colCtx, SurfaceType_GetBgCamIndex(colCtx, poly, bgId), bgId);
 }
 
-/**
- * SurfaceType Get Scene Exit Index
- */
 u32 SurfaceType_GetSceneExitIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 0) >> 8 & 0x1F;
 }
 
-/**
- * SurfaceType Get ? Property (& 0x0003_E000)
- */
-u32 func_800C99D4(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+FloorType SurfaceType_GetFloorType(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 0) >> 13 & 0x1F;
 }
 
@@ -4208,126 +4210,85 @@ u32 func_800C99FC(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 0) >> 18 & 7;
 }
 
-/**
- * SurfaceType Get Wall Property (Internal)
- */
-u32 func_800C9A24(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+WallType SurfaceType_GetWallType(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 0) >> 21 & 0x1F;
 }
 
-/**
- * SurfaceType Get Wall Flags
- */
-s32 func_800C9A4C(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
-    return sWallFlags[func_800C9A24(colCtx, poly, bgId)];
+s32 SurfaceType_GetWallFlags(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+    return sWallFlags[SurfaceType_GetWallType(colCtx, poly, bgId)];
 }
 
-/**
- * SurfaceType Is Wall Flag (1 << 0) Set
- */
-s32 func_800C9A7C(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
-    return (func_800C9A4C(colCtx, poly, bgId) & 1) ? true : false;
+s32 SurfaceType_CheckWallFlag0(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+    return (SurfaceType_GetWallFlags(colCtx, poly, bgId) & WALL_FLAG_0) ? true : false;
 }
 
-/**
- * SurfaceType Is Wall Flag (1 << 1) Set
- */
-s32 func_800C9AB0(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
-    return (func_800C9A4C(colCtx, poly, bgId) & 2) ? true : false;
+s32 SurfaceType_CheckWallFlag1(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+    return (SurfaceType_GetWallFlags(colCtx, poly, bgId) & WALL_FLAG_1) ? true : false;
 }
 
-/**
- * SurfaceType Is Wall Flag (1 << 2) Set
- */
-s32 func_800C9AE4(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
-    return (func_800C9A4C(colCtx, poly, bgId) & 4) ? true : false;
+s32 SurfaceType_CheckWallFlag2(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+    return (SurfaceType_GetWallFlags(colCtx, poly, bgId) & WALL_FLAG_2) ? true : false;
 }
 
-u32 func_800C9B18(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+FloorProperty SurfaceType_GetFloorProperty2(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 0) >> 26 & 0xF;
 }
 
-/**
- * SurfaceType Get Floor Property
- */
-u32 func_800C9B40(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+FloorProperty SurfaceType_GetFloorProperty(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 0) >> 26 & 0xF;
 }
 
-/**
- * SurfaceType Is Floor Minus 1
- */
-u32 func_800C9B68(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+u32 SurfaceType_IsSoft(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 0) >> 30 & 1;
 }
 
-/**
- * SurfaceType Is Horse Blocked
- */
 u32 SurfaceType_IsHorseBlocked(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 0) >> 31 & 1;
 }
 
-u32 func_800C9BB8(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+SurfaceMaterial SurfaceType_GetMaterial(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 1) & 0xF;
 }
 
-/**
- * SurfaceType Get Poly Sfx
- */
-u16 SurfaceType_GetSfx(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
-    s32 id = func_800C9BB8(colCtx, poly, bgId);
+u16 SurfaceType_GetSfxOffset(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+    SurfaceMaterial surfaceMaterial = SurfaceType_GetMaterial(colCtx, poly, bgId);
 
-    if ((id < 0) || (id > 14)) {
-        return NA_SE_PL_WALK_GROUND - SFX_FLAG;
+    if ((surfaceMaterial < 0) || (surfaceMaterial >= ARRAY_COUNT(sSurfaceSfxOffsets))) {
+        return SURFACE_SFX_OFFSET_DIRT;
     }
-    return sSurfaceTypeSfx[id];
+
+    return sSurfaceSfxOffsets[surfaceMaterial];
 }
 
 /**
- * SurfaceType Get ? (same indexer as Get Poly Sfx)
+ * Checks if the material has the bitwise propertyType
  */
-s32 func_800C9C24(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId, s32 arg3) {
-    s32 id = func_800C9BB8(colCtx, poly, bgId);
+s32 SurfaceType_HasMaterialProperty(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId, s32 propertyType) {
+    SurfaceMaterial surfaceMaterial = SurfaceType_GetMaterial(colCtx, poly, bgId);
 
-    if ((id < 0) || (id > 14)) {
+    if ((surfaceMaterial < 0) || (surfaceMaterial >= ARRAY_COUNT(sSurfaceMaterialProperties))) {
         return 0;
     }
-    return D_801B46C0[id] & arg3;
+
+    return sSurfaceMaterialProperties[surfaceMaterial] & propertyType;
 }
 
-/**
- * SurfaceType get terrain slope surface
- */
-u32 SurfaceType_GetSlope(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+FloorEffect SurfaceType_GetFloorEffect(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 1) >> 4 & 3;
 }
 
-/**
- * SurfaceType get surface lighting setting
- */
 u32 SurfaceType_GetLightSettingIndex(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 1) >> 6 & 0x1F;
 }
 
-/**
- * SurfaceType get echo
- */
 u32 SurfaceType_GetEcho(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 1) >> 11 & 0x3F;
 }
 
-/**
- * SurfaceType Is Hookshot Surface
- */
 u32 SurfaceType_IsHookshotSurface(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 1) >> 17 & 1;
 }
 
-/**
- * CollisionPoly is ignored by entities
- * Returns true if poly is ignored by entities, else false
- */
 s32 SurfaceType_IsIgnoredByEntities(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     u32 flags;
 
@@ -4338,10 +4299,6 @@ s32 SurfaceType_IsIgnoredByEntities(CollisionContext* colCtx, CollisionPoly* pol
     return !!flags;
 }
 
-/**
- * CollisionPoly is ignored by projectiles
- * Returns true if poly is ignored by projectiles, else false
- */
 s32 SurfaceType_IsIgnoredByProjectiles(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     u32 flags;
 
@@ -4384,10 +4341,7 @@ s32 func_800C9DDC(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return !!flags;
 }
 
-/**
- * SurfaceType Get Conveyor Surface Speed
- */
-u32 SurfaceType_GetConveyorSpeed(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
+ConveyorSpeed SurfaceType_GetConveyorSpeed(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return SurfaceType_GetData(colCtx, poly, bgId, 1) >> 18 & 7;
 }
 
@@ -4405,9 +4359,6 @@ u32 SurfaceType_GetConveyorDirection(CollisionContext* colCtx, CollisionPoly* po
     return data & 0x3F;
 }
 
-/**
- * SurfaceType is Wall Damage
- */
 u32 SurfaceType_IsWallDamage(CollisionContext* colCtx, CollisionPoly* poly, s32 bgId) {
     return (SurfaceType_GetData(colCtx, poly, bgId, 1) & 0x8000000) ? true : false;
 }
diff --git a/src/code/z_en_hy_code.c b/src/code/z_en_hy_code.c
index 2f508bb948..674f4bfa4c 100644
--- a/src/code/z_en_hy_code.c
+++ b/src/code/z_en_hy_code.c
@@ -250,19 +250,20 @@ void EnHy_UpdateCollider(EnHy* enHy, PlayState* play) {
 s32 EnHy_PlayWalkingSound(EnHy* enHy, PlayState* play, f32 distAboveThreshold) {
     u8 wasLeftFootOnGround = enHy->isLeftFootOnGround;
     u8 wasRightFootOnGround = enHy->isRightFootOnGround;
-    s32 waterSfxId;
+    SurfaceSfxOffset surfaceSfxOffset;
     u16 sfxId;
     u8 isFootOnGround;
 
     if (enHy->actor.bgCheckFlags & BGCHECKFLAG_WATER) {
         if (enHy->actor.depthInWater < 20.0f) {
-            waterSfxId = NA_SE_PL_WALK_WATER0 - SFX_FLAG;
+            surfaceSfxOffset = SURFACE_SFX_OFFSET_WATER_SHALLOW;
         } else {
-            waterSfxId = NA_SE_PL_WALK_WATER1 - SFX_FLAG;
+            surfaceSfxOffset = SURFACE_SFX_OFFSET_WATER_DEEP;
         }
-        sfxId = waterSfxId + SFX_FLAG;
+        sfxId = NA_SE_PL_WALK_GROUND + surfaceSfxOffset;
     } else {
-        sfxId = SurfaceType_GetSfx(&play->colCtx, enHy->actor.floorPoly, enHy->actor.floorBgId) + SFX_FLAG;
+        sfxId = NA_SE_PL_WALK_GROUND +
+                SurfaceType_GetSfxOffset(&play->colCtx, enHy->actor.floorPoly, enHy->actor.floorBgId);
     }
 
     enHy->isLeftFootOnGround = isFootOnGround = SubS_IsFloorAbove(play, &enHy->leftFootPos, distAboveThreshold);
diff --git a/src/code/z_message.c b/src/code/z_message.c
index 01e4a366d8..8681967e67 100644
--- a/src/code/z_message.c
+++ b/src/code/z_message.c
@@ -106,7 +106,7 @@ void Message_CloseTextbox(PlayState* play) {
         msgCtx->stateTimer = 2;
         msgCtx->msgMode = 0x43;
         msgCtx->unk12020 = 0;
-        play_sound(NA_SE_PL_WALK_GROUND - SFX_FLAG);
+        play_sound(NA_SE_NONE);
     }
 }
 
diff --git a/src/code/z_play.c b/src/code/z_play.c
index 08309b32f0..1788024863 100644
--- a/src/code/z_play.c
+++ b/src/code/z_play.c
@@ -1,3 +1,4 @@
+#include "prevent_bss_reordering.h"
 #include "global.h"
 #include "buffers.h"
 #include "z64debug_display.h"
diff --git a/src/code/z_quake.c b/src/code/z_quake.c
index e1e12bbf16..d8d526ca37 100644
--- a/src/code/z_quake.c
+++ b/src/code/z_quake.c
@@ -477,13 +477,13 @@ void Distortion_ClearType(s32 type) {
 /**
  * Checks that the bg surface is an underwater conveyor type and if so, returns the conveyor speed
  */
-s32 Distortion_GetUnderwaterCurrentSpeed(Player* player) {
+ConveyorSpeed Distortion_GetUnderwaterCurrentSpeed(Player* player) {
     if (!SurfaceType_IsFloorConveyor(&sDistortionRequest.play->colCtx, player->actor.floorPoly,
                                      player->actor.floorBgId)) {
         return SurfaceType_GetConveyorSpeed(&sDistortionRequest.play->colCtx, player->actor.floorPoly,
                                             player->actor.floorBgId);
     }
-    return 0;
+    return CONVEYOR_SPEED_DISABLED;
 }
 
 void Distortion_Update(void) {
@@ -709,21 +709,21 @@ void Distortion_Update(void) {
             rotZ = 0.3f;
 
             switch (Distortion_GetUnderwaterCurrentSpeed(player)) {
-                case 3:
+                case CONVEYOR_SPEED_FAST:
                     xScale = -0.06f;
                     yScale = 0.1f;
                     zScale = 0.03f;
                     speed = 0.33f;
                     break;
 
-                case 2:
+                case CONVEYOR_SPEED_MEDIUM:
                     xScale = -0.06f;
                     yScale = 0.1f;
                     zScale = 0.03f;
                     speed = 0.33f;
                     break;
 
-                case 1:
+                case CONVEYOR_SPEED_SLOW:
                     xScale = -0.06f;
                     yScale = 0.1f;
                     zScale = 0.03f;
@@ -759,21 +759,21 @@ void Distortion_Update(void) {
             rotY = 0.0f;
             rotZ = 0.0f;
             switch (Distortion_GetUnderwaterCurrentSpeed(player)) {
-                case 3:
+                case CONVEYOR_SPEED_FAST:
                     xScale = 0.12f;
                     yScale = 0.12f;
                     zScale = 0.08f;
                     speed = 0.18f;
                     break;
 
-                case 2:
+                case CONVEYOR_SPEED_MEDIUM:
                     xScale = 0.12f;
                     yScale = 0.12f;
                     zScale = 0.08f;
                     speed = 0.12f;
                     break;
 
-                case 1:
+                case CONVEYOR_SPEED_SLOW:
                     xScale = 0.12f;
                     yScale = 0.12f;
                     zScale = 0.08f;
diff --git a/src/libultra/io/pimgr.c b/src/libultra/io/pimgr.c
index fefffd6533..63cc7ba668 100644
--- a/src/libultra/io/pimgr.c
+++ b/src/libultra/io/pimgr.c
@@ -19,7 +19,7 @@ void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQ, OSMesg* cmdBuf, s32 cmdMsgC
         if (!__osPiAccessQueueEnabled) {
             __osPiCreateAccessQueue();
         }
-        osSetEventMesg(8, &D_8009E3D0, (OSMesg)0x22222222);
+        osSetEventMesg(OS_EVENT_PI, &D_8009E3D0, (OSMesg)0x22222222);
         oldPri = -1;
         myPri = osGetThreadPri(NULL);
         if (myPri < pri) {
diff --git a/src/overlays/actors/ovl_Bg_Ikana_Block/z_bg_ikana_block.c b/src/overlays/actors/ovl_Bg_Ikana_Block/z_bg_ikana_block.c
index b6206ecb76..5f35aaa4d9 100644
--- a/src/overlays/actors/ovl_Bg_Ikana_Block/z_bg_ikana_block.c
+++ b/src/overlays/actors/ovl_Bg_Ikana_Block/z_bg_ikana_block.c
@@ -336,8 +336,8 @@ void func_80B7F398(BgIkanaBlock* this, PlayState* play) {
     if (func_80B7EE70(this, play)) {
         Actor_PlaySfx(&this->dyna.actor, NA_SE_EV_BLOCK_BOUND);
         Actor_PlaySfx(&this->dyna.actor,
-                      SurfaceType_GetSfx(&play->colCtx, this->dyna.actor.floorPoly, this->dyna.actor.floorBgId) +
-                          SFX_FLAG);
+                      NA_SE_PL_WALK_GROUND + SurfaceType_GetSfxOffset(&play->colCtx, this->dyna.actor.floorPoly,
+                                                                      this->dyna.actor.floorBgId));
         func_80B7F0A4(this);
     }
 }
diff --git a/src/overlays/actors/ovl_Dm_Stk/z_dm_stk.c b/src/overlays/actors/ovl_Dm_Stk/z_dm_stk.c
index 423c70fc5a..83bdfe71a4 100644
--- a/src/overlays/actors/ovl_Dm_Stk/z_dm_stk.c
+++ b/src/overlays/actors/ovl_Dm_Stk/z_dm_stk.c
@@ -648,7 +648,7 @@ void DmStk_PlaySfxForPlayingWithFairiesCutscene(DmStk* this, PlayState* play) {
         case 72:
         case 77:
         case 79:
-            Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_WATER2);
+            Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_GROUND + SURFACE_SFX_OFFSET_TALL_GRASS);
             Actor_PlaySfx(&this->actor, NA_SE_EN_STALKIDS_WALK);
             break;
 
diff --git a/src/overlays/actors/ovl_Door_Warp1/z_door_warp1.c b/src/overlays/actors/ovl_Door_Warp1/z_door_warp1.c
index 57fa310e18..01df277150 100644
--- a/src/overlays/actors/ovl_Door_Warp1/z_door_warp1.c
+++ b/src/overlays/actors/ovl_Door_Warp1/z_door_warp1.c
@@ -47,8 +47,8 @@ void func_808BAAF4(DoorWarp1* this, PlayState* play);
 void func_808BABF4(DoorWarp1* this, PlayState* play);
 void func_808BB8D4(DoorWarp1* this, PlayState* play, s32 arg2);
 
-static s16 D_808BC000;
-static f32 D_808BC004;
+s16 D_808BC000;
+f32 D_808BC004;
 
 ActorInit Door_Warp1_InitVars = {
     ACTOR_DOOR_WARP1,
diff --git a/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c b/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c
index 9e99d4fba1..a1e2798dfd 100644
--- a/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c
+++ b/src/overlays/actors/ovl_En_Bbfall/z_en_bbfall.c
@@ -211,9 +211,9 @@ void EnBbfall_Thaw(EnBbfall* this, PlayState* play) {
  */
 s32 EnBbfall_IsTouchingLava(EnBbfall* this, PlayState* play) {
     if (!SurfaceType_IsWallDamage(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId)) {
-        u32 floorType = func_800C99D4(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
+        FloorType floorType = SurfaceType_GetFloorType(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
 
-        if ((floorType == 2) || (floorType == 3) || (floorType == 9)) {
+        if ((floorType == FLOOR_TYPE_2) || (floorType == FLOOR_TYPE_3) || (floorType == FLOOR_TYPE_9)) {
             return true;
         }
     }
diff --git a/src/overlays/actors/ovl_En_Bom/z_en_bom.c b/src/overlays/actors/ovl_En_Bom/z_en_bom.c
index a99e9063ce..4ebdbe9166 100644
--- a/src/overlays/actors/ovl_En_Bom/z_en_bom.c
+++ b/src/overlays/actors/ovl_En_Bom/z_en_bom.c
@@ -230,7 +230,7 @@ void EnBom_Move(EnBom* this, PlayState* play) {
         Math_StepToF(&this->actor.speed, 0.0f, 0.08f);
     } else {
         Vec3f* sp58;
-        u32 sp54 = func_800C99D4(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
+        FloorType floorType = SurfaceType_GetFloorType(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
         Vec3f slopeNormal;
         s16 downwardSlopeYaw;
         f32 sp40;
@@ -239,11 +239,11 @@ void EnBom_Move(EnBom* this, PlayState* play) {
 
         sp58 = &D_80872E68[this->isPowderKeg];
 
-        if (sp54 == 5) {
+        if (floorType == FLOOR_TYPE_5) {
             sp58 = &D_80872E68[2];
         }
 
-        if ((sp54 == 4) || (sp54 == 14) || (sp54 == 15)) {
+        if ((floorType == FLOOR_TYPE_4) || (floorType == FLOOR_TYPE_14) || (floorType == FLOOR_TYPE_15)) {
             s16 sp36;
 
             Math_ApproachF(&this->actor.shape.yOffset, 0.0f, 0.1f, 50.0f);
@@ -262,8 +262,8 @@ void EnBom_Move(EnBom* this, PlayState* play) {
         sp3C += 3.0f * slopeNormal.z;
         sp38 = sqrtf(SQ(sp40) + SQ(sp3C));
 
-        if ((sp38 < this->actor.speed) ||
-            (SurfaceType_GetSlope(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == 1)) {
+        if ((sp38 < this->actor.speed) || (SurfaceType_GetFloorEffect(&play->colCtx, this->actor.floorPoly,
+                                                                      this->actor.floorBgId) == FLOOR_EFFECT_1)) {
             if (sp38 > 16.0f) {
                 this->actor.speed = 16.0f;
             } else {
@@ -286,7 +286,7 @@ void EnBom_Move(EnBom* this, PlayState* play) {
         if (this->actor.bgCheckFlags & BGCHECKFLAG_GROUND_TOUCH) {
             Actor_PlaySfx(&this->actor, this->isPowderKeg ? NA_SE_EV_TRE_BOX_BOUND : NA_SE_EV_BOMB_BOUND);
             if (this->actor.velocity.y < sp58->y) {
-                if ((sp54 == 4) || (sp54 == 14) || (sp54 == 15)) {
+                if ((floorType == FLOOR_TYPE_4) || (floorType == FLOOR_TYPE_14) || (floorType == FLOOR_TYPE_15)) {
                     this->actor.velocity.y = 0.0f;
                 } else {
                     this->actor.velocity.y = this->actor.velocity.y * sp58->z;
@@ -327,7 +327,7 @@ void EnBom_Explode(EnBom* this, PlayState* play) {
     static Color_RGBA8 D_80872E90 = { 185, 140, 70, 255 };
     static Color_RGBA8 D_80872E94 = { 255, 255, 255, 255 };
     s32 i;
-    s32 temp_s0;
+    FloorType floorType;
     f32 temp_f20;
     s32 pad;
     f32 spCC;
@@ -394,11 +394,11 @@ void EnBom_Explode(EnBom* this, PlayState* play) {
             spB4.y = this->actor.world.pos.y + 500.0f;
             spB4.z = this->actor.world.pos.z + spC0.z;
             if (BgCheck_EntityRaycastFloor3(&play->colCtx, &spB0, &spAC, &spB4) != BGCHECK_Y_MIN) {
-                temp_s0 = func_800C99D4(&play->colCtx, spB0, spAC);
+                floorType = SurfaceType_GetFloorType(&play->colCtx, spB0, spAC);
                 temp_f20 = BgCheck_EntityRaycastFloor1(&play->colCtx, &spB0, &spB4);
 
-                if ((temp_s0 == 4) || (temp_s0 == 15) || (temp_s0 == 14)) {
-                    if (temp_s0 == 4) {
+                if ((floorType == FLOOR_TYPE_4) || (floorType == FLOOR_TYPE_15) || (floorType == FLOOR_TYPE_14)) {
+                    if (floorType == FLOOR_TYPE_4) {
                         sp84 = D_80872E90;
                         sp80 = D_80872E90;
                     } else {
diff --git a/src/overlays/actors/ovl_En_Bom_Chu/z_en_bom_chu.c b/src/overlays/actors/ovl_En_Bom_Chu/z_en_bom_chu.c
index a652e574f8..175ac69a8c 100644
--- a/src/overlays/actors/ovl_En_Bom_Chu/z_en_bom_chu.c
+++ b/src/overlays/actors/ovl_En_Bom_Chu/z_en_bom_chu.c
@@ -193,7 +193,7 @@ void EnBomChu_WaitForRelease(EnBomChu* this, PlayState* play) {
 s32 EnBomChu_IsOnCollisionPoly(PlayState* play, Vec3f* posA, Vec3f* posB, Vec3f* posResult, CollisionPoly** poly,
                                s32* bgId) {
     if ((BgCheck_EntityLineTest1(&play->colCtx, posA, posB, posResult, poly, true, true, true, true, bgId)) &&
-        (!(func_800C9A4C(&play->colCtx, *poly, *bgId) & 0x30))) {
+        !(SurfaceType_GetWallFlags(&play->colCtx, *poly, *bgId) & (WALL_FLAG_4 | WALL_FLAG_5))) {
         return true;
     }
 
diff --git a/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c b/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
index bc7841ddcd..a578143377 100644
--- a/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
+++ b/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
@@ -358,7 +358,7 @@ void func_80876930(EnDodongo* this, PlayState* play, Vec3f* arg2) {
     s16 temp2;
     f32 temp3;
 
-    if (func_800C9BB8(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == COLPOLY_SURFACE_SNOW) {
+    if (SurfaceType_GetMaterial(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == SURFACE_MATERIAL_SNOW) {
         sp80 = &D_8087932C;
         sp7C = &D_80879330;
     } else {
diff --git a/src/overlays/actors/ovl_En_Elf/z_en_elf.c b/src/overlays/actors/ovl_En_Elf/z_en_elf.c
index 13075fd55c..fd800c27f5 100644
--- a/src/overlays/actors/ovl_En_Elf/z_en_elf.c
+++ b/src/overlays/actors/ovl_En_Elf/z_en_elf.c
@@ -1090,7 +1090,7 @@ void func_8088EFA4(EnElf* this, PlayState* play) {
         }
     } else if ((arrayPointerActor != NULL) && (player->targetedActor != NULL)) {
         u8 temp = this->unk_269;
-        u16 targetSfxId = this->unk_269 == 0 ? NA_SE_PL_WALK_GROUND - SFX_FLAG : NA_SE_PL_WALK_GROUND - SFX_FLAG;
+        u16 targetSfxId = (this->unk_269 == 0) ? NA_SE_NONE : NA_SE_NONE;
 
         if (!temp) {
             Actor_PlaySfx(&this->actor, targetSfxId);
diff --git a/src/overlays/actors/ovl_En_Famos/z_en_famos.c b/src/overlays/actors/ovl_En_Famos/z_en_famos.c
index 1fc83d8a1b..3d68d34d71 100644
--- a/src/overlays/actors/ovl_En_Famos/z_en_famos.c
+++ b/src/overlays/actors/ovl_En_Famos/z_en_famos.c
@@ -500,7 +500,7 @@ void EnFamos_Chase(EnFamos* this, PlayState* play) {
     this->actor.world.rot.x = -Actor_WorldPitchTowardPoint(&this->actor, &abovePlayerPos);
     Math_StepToF(&this->actor.speed, 6.0f, 0.5f);
 
-    surfaceType = func_800C9B18(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
+    surfaceType = SurfaceType_GetFloorProperty2(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
     if ((this->actor.xzDistToPlayer < 30.0f) && (this->actor.floorHeight > BGCHECK_Y_MIN) && // close enough
         (surfaceType != 0xC && surfaceType != 0xD)) {
         EnFamos_SetupAttackAim(this);
@@ -543,7 +543,7 @@ void EnFamos_Attack(EnFamos* this, PlayState* play) {
         this->emblemCollider.base.acFlags &= ~AC_ON;
     }
 
-    surfaceType = func_800C9B18(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
+    surfaceType = SurfaceType_GetFloorProperty2(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
     hitFloor = this->actor.bgCheckFlags & BGCHECKFLAG_GROUND;
     if (hitFloor || (this->actor.floorHeight == BGCHECK_Y_MIN) || (surfaceType == 0xC) || (surfaceType == 0xD)) {
         this->collider1.base.atFlags &= ~AT_ON;
diff --git a/src/overlays/actors/ovl_En_Fishing/z_en_fishing.c b/src/overlays/actors/ovl_En_Fishing/z_en_fishing.c
index af0456d57f..e91632700a 100644
--- a/src/overlays/actors/ovl_En_Fishing/z_en_fishing.c
+++ b/src/overlays/actors/ovl_En_Fishing/z_en_fishing.c
@@ -2445,7 +2445,7 @@ void EnFishing_UpdateLure(EnFishing* this, PlayState* play) {
                     sLureRot.x = 0.0f;
                     if (CHECK_BTN_ALL(input->press.button, BTN_B)) {
                         D_809101C0 += 6.0f;
-                        Audio_PlaySfxAtPos(&D_8090D614, NA_SE_PL_WALK_SAND);
+                        Audio_PlaySfxAtPos(&D_8090D614, NA_SE_PL_WALK_GROUND + SURFACE_SFX_OFFSET_SAND);
                     }
                 } else {
                     if (D_809101C0 > 150.0f) {
diff --git a/src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c b/src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c
index b429c7e4b8..b07d1f2c79 100644
--- a/src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c
+++ b/src/overlays/actors/ovl_En_Goroiwa/z_en_goroiwa.c
@@ -1431,7 +1431,7 @@ void EnGoroiwa_Update(Actor* thisx, PlayState* play) {
     Vec3f sp50;
     f32 sp4C;
     s32 sp48 = true;
-    u32 temp_v0_2;
+    FloorType floorType;
     CollisionPoly* tmp;
 
     if (!(player->stateFlags1 &
@@ -1453,9 +1453,9 @@ void EnGoroiwa_Update(Actor* thisx, PlayState* play) {
             if (this->actor.flags & ACTOR_FLAG_40) {
                 tmp = this->actor.floorPoly;
                 if (tmp != NULL) {
-                    temp_v0_2 = func_800C99D4(&play->colCtx, tmp, this->actor.floorBgId);
+                    floorType = SurfaceType_GetFloorType(&play->colCtx, tmp, this->actor.floorBgId);
 
-                    if ((temp_v0_2 == 14) || (temp_v0_2 == 15)) {
+                    if ((floorType == FLOOR_TYPE_14) || (floorType == FLOOR_TYPE_15)) {
                         if (!(this->unk_1E5 & 0x40)) {
                             sp50.x = this->actor.world.pos.x;
                             sp50.y = this->actor.floorHeight;
diff --git a/src/overlays/actors/ovl_En_Horse/z_en_horse.c b/src/overlays/actors/ovl_En_Horse/z_en_horse.c
index 59fea362a3..4b5878110e 100644
--- a/src/overlays/actors/ovl_En_Horse/z_en_horse.c
+++ b/src/overlays/actors/ovl_En_Horse/z_en_horse.c
@@ -3472,7 +3472,7 @@ s32 EnHorse_CalcFloorHeight(EnHorse* this, PlayState* play, Vec3f* pos, Collisio
 
     if ((COLPOLY_GET_NORMAL((*polyFloor)->normal.y) < 0.81915206f) ||
         SurfaceType_IsHorseBlocked(&play->colCtx, *polyFloor, *bgId) ||
-        (func_800C99D4(&play->colCtx, *polyFloor, *bgId) == 7)) {
+        (SurfaceType_GetFloorType(&play->colCtx, *polyFloor, *bgId) == FLOOR_TYPE_7)) {
         return 3; // Horse blocked surface
     }
 
@@ -3619,7 +3619,7 @@ void EnHorse_CheckFloors(EnHorse* this, PlayState* play) {
 
         if ((ny < 0.81915206f) ||
             SurfaceType_IsHorseBlocked(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) ||
-            (func_800C99D4(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == 7)) {
+            (SurfaceType_GetFloorType(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == FLOOR_TYPE_7)) {
             if (this->actor.speed >= 0.0f) {
                 EnHorse_ObstructMovement(this, play, 4, galloping);
             } else {
@@ -3891,7 +3891,7 @@ void EnHorse_UpdateBgCheckInfo(EnHorse* this, PlayState* play) {
 
     temp_f0 = COLPOLY_GET_NORMAL(obstacleFloor->normal.y);
     if ((temp_f0 < 0.81915206f) || SurfaceType_IsHorseBlocked(&play->colCtx, obstacleFloor, bgId) ||
-        (func_800C99D4(&play->colCtx, obstacleFloor, bgId) == 7)) {
+        (SurfaceType_GetFloorType(&play->colCtx, obstacleFloor, bgId) == FLOOR_TYPE_7)) {
         if ((Math_CosS(sp7E) < 0.9f) && (movingFast == true) && (this->playerControlled == true) &&
             (this->action != ENHORSE_ACTION_STOPPING) && (play->sceneId != SCENE_KOEPONARACE)) {
             this->stateFlags |= ENHORSE_FORCE_REVERSING;
@@ -3954,7 +3954,7 @@ void EnHorse_UpdateBgCheckInfo(EnHorse* this, PlayState* play) {
 
     temp_f0 = COLPOLY_GET_NORMAL(obstacleFloor->normal.y);
     if ((temp_f0 < 0.81915206f) || SurfaceType_IsHorseBlocked(&play->colCtx, obstacleFloor, bgId) ||
-        (func_800C99D4(&play->colCtx, obstacleFloor, bgId) == 7)) {
+        (SurfaceType_GetFloorType(&play->colCtx, obstacleFloor, bgId) == FLOOR_TYPE_7)) {
         if ((movingFast == true) && (this->playerControlled == true) && (this->action != ENHORSE_ACTION_STOPPING) &&
             (play->sceneId != SCENE_KOEPONARACE)) {
             this->stateFlags |= ENHORSE_FORCE_REVERSING;
@@ -4122,7 +4122,8 @@ s32 EnHorse_UpdateConveyors(EnHorse* this, PlayState* play) {
     s16 conveyorDir;
 
     if ((this->actor.floorPoly == NULL) || (&this->actor != player->rideActor) ||
-        !SurfaceType_GetConveyorSpeed(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId)) {
+        (SurfaceType_GetConveyorSpeed(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) ==
+         CONVEYOR_SPEED_DISABLED)) {
         return false;
     }
 
diff --git a/src/overlays/actors/ovl_En_In/z_en_in.c b/src/overlays/actors/ovl_En_In/z_en_in.c
index e3d183fe47..27c8de507a 100644
--- a/src/overlays/actors/ovl_En_In/z_en_in.c
+++ b/src/overlays/actors/ovl_En_In/z_en_in.c
@@ -169,12 +169,12 @@ s32 func_808F3178(EnIn* this, PlayState* play) {
     u8 tmp;
 
     this->unk260 = tmp = SubS_IsFloorAbove(play, &this->unk248, -6.0f);
-    if (this->unk260 != 0 && prevUnk260 == 0 && tmp) {
-        Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_CONCRETE);
+    if ((this->unk260 != 0) && (prevUnk260 == 0) && tmp) {
+        Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_GROUND + SURFACE_SFX_OFFSET_STONE);
     }
     this->unk261 = tmp = SubS_IsFloorAbove(play, &this->unk254, -6.0f);
-    if (this->unk261 != 0 && prevUnk261 == 0 && tmp) {
-        Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_CONCRETE);
+    if ((this->unk261 != 0) && (prevUnk261 == 0) && tmp) {
+        Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_GROUND + SURFACE_SFX_OFFSET_STONE);
     }
 
     return 0;
diff --git a/src/overlays/actors/ovl_En_Kame/z_en_kame.c b/src/overlays/actors/ovl_En_Kame/z_en_kame.c
index 0a9689b179..9777c7433a 100644
--- a/src/overlays/actors/ovl_En_Kame/z_en_kame.c
+++ b/src/overlays/actors/ovl_En_Kame/z_en_kame.c
@@ -289,11 +289,12 @@ void func_80AD75A8(EnKame* this, PlayState* play) {
 
     if ((this->actor.bgCheckFlags & BGCHECKFLAG_GROUND) && (this->actor.speed >= 3.0f)) {
         if ((play->gameplayFrames % 2) == 0) {
-            u32 temp_v0 = func_800C9BB8(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
+            SurfaceMaterial surfaceMaterial =
+                SurfaceType_GetMaterial(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
 
-            if ((temp_v0 == 0) || (temp_v0 == 1)) {
+            if ((surfaceMaterial == SURFACE_MATERIAL_DIRT) || (surfaceMaterial == SURFACE_MATERIAL_SAND)) {
                 func_800B1210(play, &this->actor.world.pos, &D_80AD8E5C, &gZeroVec3f, 550, 100);
-            } else if (temp_v0 == 14) {
+            } else if (surfaceMaterial == SURFACE_MATERIAL_SNOW) {
                 func_800B0DE0(play, &this->actor.world.pos, &D_80AD8E5C, &gZeroVec3f, &D_80AD8E54, &D_80AD8E58, 550,
                               100);
             }
diff --git a/src/overlays/actors/ovl_En_Kanban/z_en_kanban.c b/src/overlays/actors/ovl_En_Kanban/z_en_kanban.c
index 0390e14597..c4ef32e31c 100644
--- a/src/overlays/actors/ovl_En_Kanban/z_en_kanban.c
+++ b/src/overlays/actors/ovl_En_Kanban/z_en_kanban.c
@@ -209,7 +209,7 @@ void EnKanban_Update(Actor* thisx, PlayState* play) {
     Vec3f offset;
     EnKanban* piece;
     EnKanban* signpost;
-    s32 temp_v0_18;
+    FloorType floorType;
     f32 phi_f0;
     s32 pad2;
 
@@ -517,11 +517,11 @@ void EnKanban_Update(Actor* thisx, PlayState* play) {
             }
 
             if (onGround) {
-                temp_v0_18 = func_800C99D4(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
+                floorType = SurfaceType_GetFloorType(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
 
-                if ((temp_v0_18 == 15) || (temp_v0_18 == 14)) {
+                if ((floorType == FLOOR_TYPE_15) || (floorType == FLOOR_TYPE_14)) {
                     this->unk_197 = 1;
-                } else if (temp_v0_18 == 5) {
+                } else if (floorType == FLOOR_TYPE_5) {
                     this->unk_197 = -1;
                 }
 
@@ -623,7 +623,7 @@ void EnKanban_Update(Actor* thisx, PlayState* play) {
 
             if (bounced) {
                 if (this->unk_197 > 0) {
-                    Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_SNOW);
+                    Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_GROUND + SURFACE_SFX_OFFSET_SNOW);
                 } else {
                     Actor_PlaySfx(&this->actor, NA_SE_EV_WOODPLATE_BOUND);
                 }
diff --git a/src/overlays/actors/ovl_En_Mm/z_en_mm.c b/src/overlays/actors/ovl_En_Mm/z_en_mm.c
index ad25aa70c5..3aef8341a0 100644
--- a/src/overlays/actors/ovl_En_Mm/z_en_mm.c
+++ b/src/overlays/actors/ovl_En_Mm/z_en_mm.c
@@ -149,7 +149,8 @@ void func_80965DB4(EnMm* this, PlayState* play) {
             temp_f2 = sqrtf(SQ(temp_f14) + SQ(temp_f12));
 
             if ((temp_f2 < this->actor.speed) ||
-                (SurfaceType_GetSlope(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == 1)) {
+                (SurfaceType_GetFloorEffect(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) ==
+                 FLOOR_EFFECT_1)) {
                 this->actor.speed = CLAMP_MAX(temp_f2, 16.0f);
                 this->actor.world.rot.y = Math_Atan2S_XY(temp_f12, temp_f14);
             }
diff --git a/src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c b/src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c
index 88e69021f0..99783d77d2 100644
--- a/src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c
+++ b/src/overlays/actors/ovl_En_Mushi2/z_en_mushi2.c
@@ -1089,8 +1089,9 @@ void func_80A6B0D8(EnMushi2* this, PlayState* play) {
         s32 sp44 = 0;
 
         if (this->poly != NULL) {
-            u32 temp_v0 = func_800C99D4(&play->colCtx, this->poly, this->polyBgId);
-            if ((temp_v0 == 5) || (temp_v0 == 14) || (temp_v0 == 15)) {
+            FloorType floorType = SurfaceType_GetFloorType(&play->colCtx, this->poly, this->polyBgId);
+
+            if ((floorType == FLOOR_TYPE_5) || (floorType == FLOOR_TYPE_14) || (floorType == FLOOR_TYPE_15)) {
                 sp44 = 1;
             }
         }
diff --git a/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c b/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
index 15e65b6ce7..9c6fe4a9da 100644
--- a/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
+++ b/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
@@ -140,11 +140,12 @@ void EnNutsball_Update(Actor* thisx, PlayState* play2) {
                                 UPDBGCHECKINFO_FLAG_1 | UPDBGCHECKINFO_FLAG_2 | UPDBGCHECKINFO_FLAG_4);
 
         if (this->actor.bgCheckFlags & BGCHECKFLAG_WALL) {
-            if (func_800C9A4C(&play->colCtx, this->actor.wallPoly, this->actor.wallBgId) & 0x30) {
+            if (SurfaceType_GetWallFlags(&play->colCtx, this->actor.wallPoly, this->actor.wallBgId) &
+                (WALL_FLAG_4 | WALL_FLAG_5)) {
                 this->actor.bgCheckFlags &= ~BGCHECKFLAG_WALL;
                 if (BgCheck_EntityLineTest1(&play->colCtx, &this->actor.prevPos, &worldPos, &this->actor.world.pos,
                                             &poly, true, false, false, true, &bgId)) {
-                    if (func_800C9A4C(&play->colCtx, poly, bgId) & 0x30) {
+                    if (SurfaceType_GetWallFlags(&play->colCtx, poly, bgId) & (WALL_FLAG_4 | WALL_FLAG_5)) {
                         this->actor.world.pos.x += this->actor.velocity.x * 0.01f;
                         this->actor.world.pos.z += this->actor.velocity.z * 0.01f;
                     } else {
diff --git a/src/overlays/actors/ovl_En_Rat/z_en_rat.c b/src/overlays/actors/ovl_En_Rat/z_en_rat.c
index 39a240e016..d9c2d61f20 100644
--- a/src/overlays/actors/ovl_En_Rat/z_en_rat.c
+++ b/src/overlays/actors/ovl_En_Rat/z_en_rat.c
@@ -355,7 +355,8 @@ s32 EnRat_IsOnCollisionPoly(PlayState* play, Vec3f* posA, Vec3f* posB, Vec3f* po
     }
 
     if (BgCheck_EntityLineTest1(&play->colCtx, posA, posB, posResult, poly, 1, 1, 1, 1, bgId)) {
-        if (!(func_800C9A4C(&play->colCtx, *poly, *bgId) & 0x30) && (!isOnWater || (waterSurface <= posResult->y))) {
+        if (!(SurfaceType_GetWallFlags(&play->colCtx, *poly, *bgId) & (WALL_FLAG_4 | WALL_FLAG_5)) &&
+            (!isOnWater || (waterSurface <= posResult->y))) {
             return true;
         }
     }
diff --git a/src/overlays/actors/ovl_En_Ru/z_en_ru.c b/src/overlays/actors/ovl_En_Ru/z_en_ru.c
index 47d05f8ab3..527d41b992 100644
--- a/src/overlays/actors/ovl_En_Ru/z_en_ru.c
+++ b/src/overlays/actors/ovl_En_Ru/z_en_ru.c
@@ -138,7 +138,7 @@ s32 EnRu_ChangeAnim(SkelAnime* skelAnime, s16 animIndex) {
 s32 EnRu_PlayWalkingSound(EnRu* this, PlayState* play) {
     u8 leftWasGrounded;
     u8 rightWasGrounded;
-    s32 waterSfxId;
+    SurfaceSfxOffset surfaceSfxOffset;
     s16 sfxId;
     u8 isFootGrounded;
 
@@ -147,15 +147,16 @@ s32 EnRu_PlayWalkingSound(EnRu* this, PlayState* play) {
 
     if (this->actor.bgCheckFlags & BGCHECKFLAG_WATER) {
         if (this->actor.depthInWater < 20.0f) {
-            waterSfxId = NA_SE_PL_WALK_WATER0 - SFX_FLAG;
+            surfaceSfxOffset = SURFACE_SFX_OFFSET_WATER_SHALLOW;
         } else {
-            waterSfxId = NA_SE_PL_WALK_WATER1 - SFX_FLAG;
+            surfaceSfxOffset = SURFACE_SFX_OFFSET_WATER_DEEP;
         }
 
-        sfxId = waterSfxId + SFX_FLAG;
+        sfxId = NA_SE_PL_WALK_GROUND + surfaceSfxOffset;
 
     } else {
-        sfxId = SurfaceType_GetSfx(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) + SFX_FLAG;
+        sfxId = NA_SE_PL_WALK_GROUND +
+                SurfaceType_GetSfxOffset(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
     }
 
     this->isLeftFootGrounded = isFootGrounded = SubS_IsFloorAbove(play, &this->leftFootPos, -6.0f);
diff --git a/src/overlays/actors/ovl_En_Sw/z_en_sw.c b/src/overlays/actors/ovl_En_Sw/z_en_sw.c
index bcf380cba4..f376057079 100644
--- a/src/overlays/actors/ovl_En_Sw/z_en_sw.c
+++ b/src/overlays/actors/ovl_En_Sw/z_en_sw.c
@@ -352,7 +352,7 @@ s32 func_808D9440(PlayState* play, Vec3f* posA, Vec3f* posB, Vec3f* posResult, C
     s32 ret = false;
 
     if (BgCheck_EntityLineTest1(&play->colCtx, posA, posB, posResult, outPoly, true, true, true, true, bgId) &&
-        !(func_800C9A4C(&play->colCtx, *outPoly, *bgId) & 0x30)) {
+        !(SurfaceType_GetWallFlags(&play->colCtx, *outPoly, *bgId) & (WALL_FLAG_4 | WALL_FLAG_5))) {
         ret = true;
     }
     return ret;
diff --git a/src/overlays/actors/ovl_En_Test/z_en_test.c b/src/overlays/actors/ovl_En_Test/z_en_test.c
index 7f0a3e9715..d98790c6f5 100644
--- a/src/overlays/actors/ovl_En_Test/z_en_test.c
+++ b/src/overlays/actors/ovl_En_Test/z_en_test.c
@@ -161,18 +161,18 @@ void EnTest_Init(Actor* thisx, PlayState* play2) {
     PlayState* play = play2;
     EnTest* this = THIS;
     MtxF sp38;
-    s32 sp34;
+    s32 bgId;
 
     this->unk_209 = 0;
     this->unk_174 = 0;
 
     if (thisx->params > 0) {
         Actor_SetScale(thisx, thisx->params / 100000.0f);
-        this->unk_20A = 0;
+        this->surfaceMaterial = SURFACE_MATERIAL_DIRT;
     } else {
         thisx->floorPoly = NULL;
         thisx->world.pos.y += 10.0f;
-        thisx->floorHeight = BgCheck_EntityRaycastFloor3(&play->colCtx, &thisx->floorPoly, &sp34, &thisx->world.pos);
+        thisx->floorHeight = BgCheck_EntityRaycastFloor3(&play->colCtx, &thisx->floorPoly, &bgId, &thisx->world.pos);
 
         if ((thisx->floorPoly == NULL) || (thisx->floorHeight == BGCHECK_Y_MIN)) {
             Actor_Kill(thisx);
@@ -183,7 +183,7 @@ void EnTest_Init(Actor* thisx, PlayState* play2) {
         func_800C0094(thisx->floorPoly, thisx->world.pos.x, thisx->floorHeight, thisx->world.pos.z, &sp38);
         Matrix_MtxFToYXZRot(&sp38, &thisx->shape.rot, true);
         thisx->world.rot = thisx->shape.rot;
-        this->unk_20A = func_800C9BB8(&play->colCtx, thisx->floorPoly, sp34);
+        this->surfaceMaterial = SurfaceType_GetMaterial(&play->colCtx, thisx->floorPoly, bgId);
     }
 
     func_80183430(&this->skeletonInfo, &gameplay_keep_Blob_06EB70, &gameplay_keep_Blob_06BB0C, this->unk_178,
@@ -257,7 +257,8 @@ void EnTest_Draw(Actor* thisx, PlayState* play) {
         sp2C = 29;
     }
 
-    if ((this->unk_20A == 15) || (this->unk_20A == 14)) {
+    //! @bug Checks for non-existent SURFACE_MATERIAL_MAX material
+    if ((this->surfaceMaterial == SURFACE_MATERIAL_MAX) || (this->surfaceMaterial == SURFACE_MATERIAL_SNOW)) {
         AnimatedMat_DrawStep(play, Lib_SegmentedToVirtual(gameplay_keep_Matanimheader_06B730), sp2C);
     } else {
         AnimatedMat_DrawStep(play, Lib_SegmentedToVirtual(gameplay_keep_Matanimheader_06B6A0), sp2C);
diff --git a/src/overlays/actors/ovl_En_Test/z_en_test.h b/src/overlays/actors/ovl_En_Test/z_en_test.h
index 2b8d62993f..68395a96a7 100644
--- a/src/overlays/actors/ovl_En_Test/z_en_test.h
+++ b/src/overlays/actors/ovl_En_Test/z_en_test.h
@@ -24,7 +24,7 @@ typedef struct EnTest {
     /* 0x1C0 */ Vec3s unk_1C0[12];
     /* 0x208 */ u8 unk_208;
     /* 0x209 */ u8 unk_209;
-    /* 0x20A */ u8 unk_20A;
+    /* 0x20A */ u8 surfaceMaterial;
     /* 0x20C */ EnTestStruct unk_20C[20];
 } EnTest; // size = 0x6BC
 
diff --git a/src/overlays/actors/ovl_En_Tite/z_en_tite.c b/src/overlays/actors/ovl_En_Tite/z_en_tite.c
index 5b77c13990..3d5c7a7411 100644
--- a/src/overlays/actors/ovl_En_Tite/z_en_tite.c
+++ b/src/overlays/actors/ovl_En_Tite/z_en_tite.c
@@ -197,7 +197,7 @@ void func_80893A18(EnTite* this) {
 
 s32 func_80893A34(EnTite* this, PlayState* play) {
     if ((this->actor.params == ENTITE_MINUS_2) && (this->actor.bgCheckFlags & BGCHECKFLAG_GROUND) &&
-        (func_800C99D4(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == 5)) {
+        (SurfaceType_GetFloorType(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == FLOOR_TYPE_5)) {
         return true;
     }
     return false;
@@ -240,13 +240,14 @@ void func_80893BCC(EnTite* this, PlayState* play) {
     s32 j;
 
     if (this->actor.bgCheckFlags & BGCHECKFLAG_GROUND_TOUCH) {
-        u32 surface = func_800C9BB8(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
+        SurfaceMaterial surfaceMaterial =
+            SurfaceType_GetMaterial(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
 
-        if ((surface == COLPOLY_SURFACE_GROUND) || (surface == COLPOLY_SURFACE_SAND)) {
+        if ((surfaceMaterial == SURFACE_MATERIAL_DIRT) || (surfaceMaterial == SURFACE_MATERIAL_SAND)) {
             for (i = 5; i < ARRAY_COUNT(this->limbPos); i++) {
                 func_800BBFB0(play, &this->limbPos[i], 1.0f, 2, 80, 15, 1);
             }
-        } else if (surface == COLPOLY_SURFACE_SNOW) {
+        } else if (surfaceMaterial == SURFACE_MATERIAL_SNOW) {
             Vec3f* ptr;
 
             for (i = 5; i < ARRAY_COUNT(this->limbPos); i++) {
diff --git a/src/overlays/actors/ovl_En_Tk/z_en_tk.c b/src/overlays/actors/ovl_En_Tk/z_en_tk.c
index 849214abac..91fd666354 100644
--- a/src/overlays/actors/ovl_En_Tk/z_en_tk.c
+++ b/src/overlays/actors/ovl_En_Tk/z_en_tk.c
@@ -1035,13 +1035,13 @@ s32 func_80AEE86C(EnTk* this, PlayState* play) {
     s32 pad;
     s32 ret = false;
     s32 pad2;
-    CollisionPoly* sp38;
-    s32 sp34;
+    CollisionPoly* groundPoly;
+    s32 bgId;
     Vec3f sp28;
 
     Lib_Vec3f_TranslateAndRotateY(&this->actor.world.pos, this->actor.shape.rot.y, &D_80AEFA78, &sp28);
-    if ((BgCheck_EntityRaycastFloor3(&play->colCtx, &sp38, &sp34, &sp28) != BGCHECK_Y_MIN) &&
-        (func_800C9BB8(&play->colCtx, sp38, sp34) == 1) && (this->unk_2D0 == (u32)1) &&
+    if ((BgCheck_EntityRaycastFloor3(&play->colCtx, &groundPoly, &bgId, &sp28) != BGCHECK_Y_MIN) &&
+        (SurfaceType_GetMaterial(&play->colCtx, groundPoly, bgId) == SURFACE_MATERIAL_SAND) && (this->unk_2D0 == 1) &&
         (this->actor.xyzDistToPlayerSq <= SQ(115.0f)) &&
         func_80AEE7E0(&this->actor.world.pos, 100.0f, this->unk_324, this->unk_36C) &&
         (((this->unk_2CA & 2) && (Math_Vec3f_DistXZ(&this->unk_300, &sp28) >= 100.0f)) || !(this->unk_2CA & 2)) &&
@@ -1312,7 +1312,8 @@ void EnTk_Update(Actor* thisx, PlayState* play) {
     Actor_MoveWithGravity(&this->actor);
     Actor_UpdateBgCheckInfo(play, &this->actor, 10.0f, 10.0f, 0.0f, UPDBGCHECKINFO_FLAG_1 | UPDBGCHECKINFO_FLAG_4);
 
-    if ((this->unk_2B0 == 0) && (func_800C9B40(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) == 12)) {
+    if ((this->unk_2B0 == 0) && (SurfaceType_GetFloorProperty(&play->colCtx, this->actor.floorPoly,
+                                                              this->actor.floorBgId) == FLOOR_PROPERTY_12)) {
         Math_Vec3f_Copy(&this->actor.world.pos, &this->actor.prevPos);
         this->unk_2CA |= 0x200;
         this->actor.velocity.y = 0.0f;
diff --git a/src/overlays/actors/ovl_En_Wf/z_en_wf.c b/src/overlays/actors/ovl_En_Wf/z_en_wf.c
index 7d38f370f5..44a50e99d3 100644
--- a/src/overlays/actors/ovl_En_Wf/z_en_wf.c
+++ b/src/overlays/actors/ovl_En_Wf/z_en_wf.c
@@ -471,14 +471,15 @@ void func_80990C6C(EnWf* this, PlayState* play, s32 arg2) {
     static Color_RGBA8 D_809942EC = { 255, 255, 255, 255 };
     s32 i;
     Vec3f sp88;
-    u32 temp_v0;
+    FloorType floorType;
     Color_RGBA8* phi_s1;
     s16 phi_s6;
 
     if (this->actor.floorPoly != NULL) {
-        temp_v0 = func_800C99D4(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
-        if (temp_v0 != 5) {
-            if ((temp_v0 == 15) || (temp_v0 == 14)) {
+        floorType = SurfaceType_GetFloorType(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
+
+        if (floorType != FLOOR_TYPE_5) {
+            if ((floorType == FLOOR_TYPE_15) || (floorType == FLOOR_TYPE_14)) {
                 phi_s1 = &D_809942EC;
                 phi_s6 = Rand_ZeroFloat(150.0f) + 350.0f;
                 arg2 += 2;
diff --git a/src/overlays/actors/ovl_En_Zo/z_en_zo.c b/src/overlays/actors/ovl_En_Zo/z_en_zo.c
index aed16b8746..7a160e3688 100644
--- a/src/overlays/actors/ovl_En_Zo/z_en_zo.c
+++ b/src/overlays/actors/ovl_En_Zo/z_en_zo.c
@@ -122,7 +122,7 @@ s32 EnZo_ChangeAnim(SkelAnime* skelAnime, s16 animIndex) {
 s32 EnZo_PlayWalkingSound(EnZo* this, PlayState* play) {
     u8 leftWasGrounded;
     u8 rightWasGrounded;
-    s32 waterSfxId;
+    SurfaceSfxOffset surfaceSfxOffset;
     u16 sfxId;
     u8 isFootGrounded;
 
@@ -131,13 +131,14 @@ s32 EnZo_PlayWalkingSound(EnZo* this, PlayState* play) {
 
     if (this->actor.bgCheckFlags & BGCHECKFLAG_WATER) {
         if (this->actor.depthInWater < 20.0f) {
-            waterSfxId = NA_SE_PL_WALK_WATER0 - SFX_FLAG;
+            surfaceSfxOffset = SURFACE_SFX_OFFSET_WATER_SHALLOW;
         } else {
-            waterSfxId = NA_SE_PL_WALK_WATER1 - SFX_FLAG;
+            surfaceSfxOffset = SURFACE_SFX_OFFSET_WATER_DEEP;
         }
-        sfxId = waterSfxId + SFX_FLAG;
+        sfxId = NA_SE_PL_WALK_GROUND + surfaceSfxOffset;
     } else {
-        sfxId = SurfaceType_GetSfx(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId) + SFX_FLAG;
+        sfxId = NA_SE_PL_WALK_GROUND +
+                SurfaceType_GetSfxOffset(&play->colCtx, this->actor.floorPoly, this->actor.floorBgId);
     }
 
     this->isLeftFootGrounded = isFootGrounded = SubS_IsFloorAbove(play, &this->leftFootPos, -6.0f);
diff --git a/src/overlays/actors/ovl_En_Zog/z_en_zog.c b/src/overlays/actors/ovl_En_Zog/z_en_zog.c
index 349724cb35..fe5c1cd620 100644
--- a/src/overlays/actors/ovl_En_Zog/z_en_zog.c
+++ b/src/overlays/actors/ovl_En_Zog/z_en_zog.c
@@ -781,15 +781,15 @@ void func_80B94A00(EnZog* this, PlayState* play) {
 
     if ((this->unk_304 == 4) &&
         (Animation_OnFrame(&this->skelAnime, 136.0f) || Animation_OnFrame(&this->skelAnime, 155.0f))) {
-        Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_WATER0);
+        Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_GROUND + SURFACE_SFX_OFFSET_WATER_SHALLOW);
     }
 
     if ((this->unk_304 == 5) &&
         (Animation_OnFrame(&this->skelAnime, 12.0f) || Animation_OnFrame(&this->skelAnime, 37.0f))) {
         if (this->actor.depthInWater > 0.0f) {
-            Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_WATER0);
+            Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_GROUND + SURFACE_SFX_OFFSET_WATER_SHALLOW);
         } else {
-            Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_SAND);
+            Actor_PlaySfx(&this->actor, NA_SE_PL_WALK_GROUND + SURFACE_SFX_OFFSET_SAND);
         }
     }
 }
diff --git a/src/overlays/actors/ovl_Obj_Iceblock/z_obj_iceblock.c b/src/overlays/actors/ovl_Obj_Iceblock/z_obj_iceblock.c
index 85b23d232b..8aa23816d7 100644
--- a/src/overlays/actors/ovl_Obj_Iceblock/z_obj_iceblock.c
+++ b/src/overlays/actors/ovl_Obj_Iceblock/z_obj_iceblock.c
@@ -629,7 +629,8 @@ s32 func_80A24954(ObjIceblock* this, PlayState* play) {
         func_80A262BC(this);
         this->unk_2B0 = 3;
     } else if (this->unk_1B0 & 4) {
-        if (func_800C99D4(&play->colCtx, this->dyna.actor.floorPoly, this->dyna.actor.floorBgId) == 5) {
+        if (SurfaceType_GetFloorType(&play->colCtx, this->dyna.actor.floorPoly, this->dyna.actor.floorBgId) ==
+            FLOOR_TYPE_5) {
             func_80A25FA0(this);
             this->unk_2B0 = 2;
         } else {
diff --git a/src/overlays/actors/ovl_Obj_Nozoki/z_obj_nozoki.c b/src/overlays/actors/ovl_Obj_Nozoki/z_obj_nozoki.c
index 1f42807c23..bf20758ca4 100644
--- a/src/overlays/actors/ovl_Obj_Nozoki/z_obj_nozoki.c
+++ b/src/overlays/actors/ovl_Obj_Nozoki/z_obj_nozoki.c
@@ -4,7 +4,6 @@
  * Description: Sakon's Hideout Objects (Sun's Mask, doors, etc)
  */
 
-#include "prevent_bss_reordering.h"
 #include "z_obj_nozoki.h"
 #include "objects/object_secom_obj/object_secom_obj.h"
 
diff --git a/src/overlays/actors/ovl_Obj_Oshihiki/z_obj_oshihiki.c b/src/overlays/actors/ovl_Obj_Oshihiki/z_obj_oshihiki.c
index 582d43f023..3038a6d092 100644
--- a/src/overlays/actors/ovl_Obj_Oshihiki/z_obj_oshihiki.c
+++ b/src/overlays/actors/ovl_Obj_Oshihiki/z_obj_oshihiki.c
@@ -554,9 +554,9 @@ void ObjOshihiki_Fall(ObjOshihiki* this, PlayState* play) {
             ObjOshihiki_SetupOnActor(this, play);
         }
         Actor_PlaySfx(&this->dyna.actor, NA_SE_EV_BLOCK_BOUND);
-        Actor_PlaySfx(&this->dyna.actor, SurfaceType_GetSfx(&play->colCtx, this->floorPolys[this->highestFloor],
-                                                            this->floorBgIds[this->highestFloor]) +
-                                             SFX_FLAG);
+        Actor_PlaySfx(&this->dyna.actor, NA_SE_PL_WALK_GROUND + SurfaceType_GetSfxOffset(
+                                                                    &play->colCtx, this->floorPolys[this->highestFloor],
+                                                                    this->floorBgIds[this->highestFloor]));
     }
 }
 
diff --git a/src/overlays/actors/ovl_Obj_Skateblock/z_obj_skateblock.c b/src/overlays/actors/ovl_Obj_Skateblock/z_obj_skateblock.c
index 374a2f520e..80e9b12018 100644
--- a/src/overlays/actors/ovl_Obj_Skateblock/z_obj_skateblock.c
+++ b/src/overlays/actors/ovl_Obj_Skateblock/z_obj_skateblock.c
@@ -614,7 +614,8 @@ void func_80A2264C(ObjSkateblock* this, PlayState* play) {
 
     sp20 = func_80A21548(this, play);
     if (sp20 || ((this->unk_160 - this->dyna.actor.world.pos.y) > 300.0f)) {
-        if (func_800C9B40(&play->colCtx, this->dyna.actor.floorPoly, this->dyna.actor.floorBgId) == 12) {
+        if (SurfaceType_GetFloorProperty(&play->colCtx, this->dyna.actor.floorPoly, this->dyna.actor.floorBgId) ==
+            FLOOR_PROPERTY_12) {
             func_800C62BC(play, &play->colCtx.dyna, this->dyna.bgId);
             this->dyna.actor.draw = NULL;
             func_80A22728(this);
diff --git a/src/overlays/effects/ovl_Effect_Ss_Bubble/z_eff_ss_bubble.c b/src/overlays/effects/ovl_Effect_Ss_Bubble/z_eff_ss_bubble.c
index a3d2039927..681aac01d2 100644
--- a/src/overlays/effects/ovl_Effect_Ss_Bubble/z_eff_ss_bubble.c
+++ b/src/overlays/effects/ovl_Effect_Ss_Bubble/z_eff_ss_bubble.c
@@ -22,7 +22,11 @@ EffectSsInit Effect_Ss_Bubble_InitVars = {
     EffectSsBubble_Init,
 };
 
-static f32 sVecAdjMaximums[] = { 291.0f, 582.0f, 1600.0f };
+static f32 sVecAdjMaximums[] = {
+    291.0f,  // CONVEYOR_SPEED_SLOW
+    582.0f,  // CONVEYOR_SPEED_MEDIUM
+    1600.0f, // CONVEYOR_SPEED_FAST
+};
 
 u32 EffectSsBubble_Init(PlayState* play, u32 index, EffectSs* this, void* initParamsx) {
     EffectSsBubbleInitParams* initParams = (EffectSsBubbleInitParams*)initParamsx;
@@ -85,17 +89,18 @@ void EffectSsBubble_Update(PlayState* play2, u32 index, EffectSs* this) {
     }
     if (((play->gameplayFrames + index) % 8) == 0) {
         CollisionPoly* colPoly;
-        u32 speed;
-        s16 direction;
+        ConveyorSpeed conveyorSpeed;
+        s16 conveyorDir;
         f32 rVecAdjMax;
 
         BgCheck_EntityRaycastFloor2_1(play, &play->colCtx, &colPoly, &this->pos);
-        speed = SurfaceType_GetConveyorSpeed(&play->colCtx, colPoly, BGCHECK_SCENE);
-        if ((speed != 0) && !SurfaceType_IsFloorConveyor(&play->colCtx, colPoly, BGCHECK_SCENE)) {
-            direction = SurfaceType_GetConveyorDirection(&play->colCtx, colPoly, BGCHECK_SCENE) << 0xA;
-            rVecAdjMax = sVecAdjMaximums[speed - 1];
-            this->rVecAdjX = Math_SinS(direction) * rVecAdjMax;
-            this->rVecAdjZ = Math_CosS(direction) * rVecAdjMax;
+        conveyorSpeed = SurfaceType_GetConveyorSpeed(&play->colCtx, colPoly, BGCHECK_SCENE);
+        if ((conveyorSpeed != CONVEYOR_SPEED_DISABLED) &&
+            !SurfaceType_IsFloorConveyor(&play->colCtx, colPoly, BGCHECK_SCENE)) {
+            conveyorDir = SurfaceType_GetConveyorDirection(&play->colCtx, colPoly, BGCHECK_SCENE) << 10;
+            rVecAdjMax = sVecAdjMaximums[conveyorSpeed - 1];
+            this->rVecAdjX = Math_SinS(conveyorDir) * rVecAdjMax;
+            this->rVecAdjZ = Math_CosS(conveyorDir) * rVecAdjMax;
         }
     }
     this->vec.x += this->rVecAdjX / 100.0f;
diff --git a/tools/disasm/functions.txt b/tools/disasm/functions.txt
index aa67703071..ae80bd5e1d 100644
--- a/tools/disasm/functions.txt
+++ b/tools/disasm/functions.txt
@@ -1055,21 +1055,21 @@
     0x800C98CC:("BgCheck_GetBgCamFuncDataImpl",),
     0x800C9924:("BgCheck_GetBgCamFuncData",),
     0x800C99AC:("SurfaceType_GetSceneExitIndex",),
-    0x800C99D4:("func_800C99D4",),
+    0x800C99D4:("SurfaceType_GetFloorType",),
     0x800C99FC:("func_800C99FC",),
-    0x800C9A24:("func_800C9A24",),
-    0x800C9A4C:("func_800C9A4C",),
-    0x800C9A7C:("func_800C9A7C",),
-    0x800C9AB0:("func_800C9AB0",),
-    0x800C9AE4:("func_800C9AE4",),
-    0x800C9B18:("func_800C9B18",),
-    0x800C9B40:("func_800C9B40",),
-    0x800C9B68:("func_800C9B68",),
+    0x800C9A24:("SurfaceType_GetWallType",),
+    0x800C9A4C:("SurfaceType_GetWallFlags",),
+    0x800C9A7C:("SurfaceType_CheckWallFlag0",),
+    0x800C9AB0:("SurfaceType_CheckWallFlag1",),
+    0x800C9AE4:("SurfaceType_CheckWallFlag2",),
+    0x800C9B18:("SurfaceType_GetFloorProperty2",),
+    0x800C9B40:("SurfaceType_GetFloorProperty",),
+    0x800C9B68:("SurfaceType_IsSoft",),
     0x800C9B90:("SurfaceType_IsHorseBlocked",),
-    0x800C9BB8:("func_800C9BB8",),
-    0x800C9BDC:("SurfaceType_GetSfx",),
-    0x800C9C24:("func_800C9C24",),
-    0x800C9C74:("SurfaceType_GetSlope",),
+    0x800C9BB8:("SurfaceType_GetMaterial",),
+    0x800C9BDC:("SurfaceType_GetSfxOffset",),
+    0x800C9C24:("SurfaceType_HasMaterialProperty",),
+    0x800C9C74:("SurfaceType_GetFloorEffect",),
     0x800C9C9C:("SurfaceType_GetLightSettingIndex",),
     0x800C9CC4:("SurfaceType_GetEcho",),
     0x800C9CEC:("SurfaceType_IsHookshotSurface",),
diff --git a/tools/disasm/variables.txt b/tools/disasm/variables.txt
index 4dab18e3b1..6e83a53e8f 100644
--- a/tools/disasm/variables.txt
+++ b/tools/disasm/variables.txt
@@ -451,6 +451,11 @@
     0x801AEFC0:("D_801AEFC0","UNK_TYPE1","",0x1),
     0x801AEFD0:("gActorOverlayTable","ActorOverlay","[ACTOR_ID_MAX]",0x5640),
     0x801B4610:("gMaxActorId","s32","",0x4),
+    0x801B4620:("sWallFlags","u32","",0x80),
+    0x801B46A0:("sSurfaceSfxOffsets","u16","",0x1E),
+    0x801B46C0:("sSurfaceMaterialProperties","u8","",0xF),
+    0x801B46D0:("sSmallMemSceneIds","s16","",0x2),
+    0x801B46D4:("sSceneMemList","BgCheckSceneMemEntry","",0x8),
     0x801B46DC:("sSceneSubdivisionList","BgCheckSceneSubdivisionEntry","[3]",0x24),
     0x801B4700:("sCustomDynapolyMem","BgSpecialSceneMaxObjects","[1]",0x8),
     0x801B4708:("D_801B4708","UNK_TYPE1","",0x1),
diff --git a/tools/namefixer.py b/tools/namefixer.py
index 1c38d83592..bb22b1fca7 100755
--- a/tools/namefixer.py
+++ b/tools/namefixer.py
@@ -461,9 +461,19 @@ wordReplace = {
     "func_800C9704": "SurfaceType_GetBgCamIndex",
     "func_800C9924": "BgCheck_GetBgCamFuncData",
     "func_800C99AC": "SurfaceType_GetSceneExitIndex",
+    "func_800C99D4": "SurfaceType_GetFloorType",
+    "func_800C9A24": "SurfaceType_GetWallType",
+    "func_800C9A4C": "SurfaceType_GetWallFlags",
+    "func_800C9A7C": "SurfaceType_CheckWallFlag0",
+    "func_800C9AB0": "SurfaceType_CheckWallFlag1",
+    "func_800C9AE4": "SurfaceType_CheckWallFlag2",
+    "func_800C9B18": "SurfaceType_GetFloorProperty2",
+    "func_800C9B40": "SurfaceType_GetFloorProperty",
+    "func_800C9BB8": "SurfaceType_GetMaterial",
     "func_800C9B90": "SurfaceType_IsHorseBlocked",
-    "func_800C9BDC": "SurfaceType_GetSfx",
-    "func_800C9C74": "SurfaceType_GetSlope",
+    "func_800C9BDC": "SurfaceType_GetSfxOffset",
+    "SurfaceType_GetSfx": "SurfaceType_GetSfxOffset",
+    "func_800C9C74": "SurfaceType_GetFloorEffect",
     "func_800C9C9C": "SurfaceType_GetLightSettingIndex",
     "func_800C9CC4": "SurfaceType_GetEcho",
     "func_800C9CEC": "SurfaceType_IsHookshotSurface",
@@ -923,6 +933,11 @@ wordReplace = {
     "TRANS_TYPE_20": "TRANS_TYPE_FADE_DYNAMIC",
     "TRANS_TYPE_21": "TRANS_TYPE_CIRCLE",
     "TRANS_TYPE_22": "TRANS_TYPE_WIPE5",
+
+    "COLPOLY_SURFACE_GROUND": "SURFACE_MATERIAL_DIRT",
+    "COLPOLY_SURFACE_SAND": "SURFACE_MATERIAL_SAND",
+    "COLPOLY_SURFACE_SNOW": "SURFACE_MATERIAL_SNOW",
+
     # Example of custom behaviour:
     # "PLAYER": ("GET_PLAYER(play)", {"ignore": (-1, '"PLAYER"')}), # ignore "PLAYER" in sSoundBankNames
 }
diff --git a/tools/sizes/code_functions.csv b/tools/sizes/code_functions.csv
index a18086d38f..353a7f394b 100644
--- a/tools/sizes/code_functions.csv
+++ b/tools/sizes/code_functions.csv
@@ -569,21 +569,21 @@ asm/non_matchings/code/z_bgcheck/BgCheck_GetBgCamCount.s,BgCheck_GetBgCamCount,0
 asm/non_matchings/code/z_bgcheck/BgCheck_GetBgCamFuncDataImpl.s,BgCheck_GetBgCamFuncDataImpl,0x800C98CC,0x16
 asm/non_matchings/code/z_bgcheck/BgCheck_GetBgCamFuncData.s,BgCheck_GetBgCamFuncData,0x800C9924,0x22
 asm/non_matchings/code/z_bgcheck/SurfaceType_GetSceneExitIndex.s,SurfaceType_GetSceneExitIndex,0x800C99AC,0xA
-asm/non_matchings/code/z_bgcheck/func_800C99D4.s,func_800C99D4,0x800C99D4,0xA
+asm/non_matchings/code/z_bgcheck/SurfaceType_GetFloorType.s,SurfaceType_GetFloorType,0x800C99D4,0xA
 asm/non_matchings/code/z_bgcheck/func_800C99FC.s,func_800C99FC,0x800C99FC,0xA
-asm/non_matchings/code/z_bgcheck/func_800C9A24.s,func_800C9A24,0x800C9A24,0xA
-asm/non_matchings/code/z_bgcheck/func_800C9A4C.s,func_800C9A4C,0x800C9A4C,0xC
-asm/non_matchings/code/z_bgcheck/func_800C9A7C.s,func_800C9A7C,0x800C9A7C,0xD
-asm/non_matchings/code/z_bgcheck/func_800C9AB0.s,func_800C9AB0,0x800C9AB0,0xD
-asm/non_matchings/code/z_bgcheck/func_800C9AE4.s,func_800C9AE4,0x800C9AE4,0xD
-asm/non_matchings/code/z_bgcheck/func_800C9B18.s,func_800C9B18,0x800C9B18,0xA
-asm/non_matchings/code/z_bgcheck/func_800C9B40.s,func_800C9B40,0x800C9B40,0xA
-asm/non_matchings/code/z_bgcheck/func_800C9B68.s,func_800C9B68,0x800C9B68,0xA
+asm/non_matchings/code/z_bgcheck/SurfaceType_GetWallType.s,SurfaceType_GetWallType,0x800C9A24,0xA
+asm/non_matchings/code/z_bgcheck/SurfaceType_GetWallFlags.s,SurfaceType_GetWallFlags,0x800C9A4C,0xC
+asm/non_matchings/code/z_bgcheck/SurfaceType_CheckWallFlag0.s,SurfaceType_CheckWallFlag0,0x800C9A7C,0xD
+asm/non_matchings/code/z_bgcheck/SurfaceType_CheckWallFlag1.s,SurfaceType_CheckWallFlag1,0x800C9AB0,0xD
+asm/non_matchings/code/z_bgcheck/SurfaceType_CheckWallFlag2.s,SurfaceType_CheckWallFlag2,0x800C9AE4,0xD
+asm/non_matchings/code/z_bgcheck/SurfaceType_GetFloorProperty2.s,SurfaceType_GetFloorProperty2,0x800C9B18,0xA
+asm/non_matchings/code/z_bgcheck/SurfaceType_GetFloorProperty.s,SurfaceType_GetFloorProperty,0x800C9B40,0xA
+asm/non_matchings/code/z_bgcheck/SurfaceType_IsSoft.s,SurfaceType_IsSoft,0x800C9B68,0xA
 asm/non_matchings/code/z_bgcheck/SurfaceType_IsHorseBlocked.s,SurfaceType_IsHorseBlocked,0x800C9B90,0xA
-asm/non_matchings/code/z_bgcheck/func_800C9BB8.s,func_800C9BB8,0x800C9BB8,0x9
-asm/non_matchings/code/z_bgcheck/SurfaceType_GetSfx.s,SurfaceType_GetSfx,0x800C9BDC,0x12
-asm/non_matchings/code/z_bgcheck/func_800C9C24.s,func_800C9C24,0x800C9C24,0x14
-asm/non_matchings/code/z_bgcheck/SurfaceType_GetSlope.s,SurfaceType_GetSlope,0x800C9C74,0xA
+asm/non_matchings/code/z_bgcheck/SurfaceType_GetMaterial.s,SurfaceType_GetMaterial,0x800C9BB8,0x9
+asm/non_matchings/code/z_bgcheck/SurfaceType_GetSfxOffset.s,SurfaceType_GetSfxOffset,0x800C9BDC,0x12
+asm/non_matchings/code/z_bgcheck/SurfaceType_HasMaterialProperty.s,SurfaceType_HasMaterialProperty,0x800C9C24,0x14
+asm/non_matchings/code/z_bgcheck/SurfaceType_GetFloorEffect.s,SurfaceType_GetFloorEffect,0x800C9C74,0xA
 asm/non_matchings/code/z_bgcheck/SurfaceType_GetLightSettingIndex.s,SurfaceType_GetLightSettingIndex,0x800C9C9C,0xA
 asm/non_matchings/code/z_bgcheck/SurfaceType_GetEcho.s,SurfaceType_GetEcho,0x800C9CC4,0xA
 asm/non_matchings/code/z_bgcheck/SurfaceType_IsHookshotSurface.s,SurfaceType_IsHookshotSurface,0x800C9CEC,0xA