diff --git a/include/structs.h b/include/structs.h
index 858385fa..01564060 100644
--- a/include/structs.h
+++ b/include/structs.h
@@ -454,33 +454,33 @@ typedef struct LevelHeader {
   /* 0x52 */ u8 music;
   /* 0x53 */ u8 unk53;
   /* 0x54 */ u16 instruments;
-  /* 0x56 */ u8 unk56;
-  /* 0x57 */ u8 unk57;
-  /* 0x58 */ u8 unk58;
-  /* 0x59 */ u8 unk59;
-  /* 0x5A */ s16 unk5A;
-  /* 0x5C */ u8 unk5C;
-  /* 0x5D */ u8 unk5D;
-  /* 0x5E */ s16 unk5E;
-  /* 0x60 */ s16 unk60;
-  /* 0x62 */ s16 wavePower;
-  /* 0x64 */ s16 unk64; // Some form of secondary power
-  /* 0x66 */ s16 unk66;
-  /* 0x68 */ s16 unk68;
-  /* 0x6A */ u8 unk6A;
-  /* 0x6B */ u8 unk6B;
-  /* 0x6C */ s8 unk6C;
-  /* 0x6D */ s8 unk6D;
-  /* 0x6E */ s16 unk6E;
+  /* 0x56 */ u8 unk56; // values between 2 and 8 (except 5 and 7), used to determine waves count?
+  /* 0x57 */ u8 unk57; // possible values: 2,4,8,16,20, related to waves
+  /* 0x58 */ u8 unk58; // possible values: 1,2,4
+  /* 0x59 */ u8 unk59; // always 0?
+  /* 0x5A */ s16 unk5A; // values between 512 and 4608
+  /* 0x5C */ u8 unk5C; // possible values: 1,2,4
+  /* 0x5D */ u8 unk5D; // always 0?
+  /* 0x5E */ s16 unk5E; // values between 512 and 4963
+  /* 0x60 */ s16 unk60; // possible values: 120, 130, 157, 178, 187
+  /* 0x62 */ s16 wavePower; // always 256
+  /* 0x64 */ s16 unk64; // Always 153 except in Smokey Castle where it's 0 and the title screen where it's 256 (Some form of secondary power)
+  /* 0x66 */ s16 unk66; // values between 908 and 2560
+  /* 0x68 */ s16 textureId; // always 62 except in the trophy race where it's 205
+  /* 0x6A */ u8 unk6A; // values between 1 and 6
+  /* 0x6B */ u8 unk6B; // values between 1 and 6
+  /* 0x6C */ s8 unk6C; // values between 0 and 4
+  /* 0x6D */ s8 unk6D; // values between 0 and 2 except in Hot Top Volcano where it's -2
+  /* 0x6E */ s16 unk6E; // possible values: 3,5
 
     //func_800B8134 Seems to use this struct, and it differs on unk70 only.
-    union {
-  /* 0x70 */ LevelHeader_70 *unk70;
-        struct {
-  /* 0x70 */ u8 unk70_u8;
-  /* 0x71 */ u8 unk71;
-        };
-    };
+  union {
+  /* 0x70 */ LevelHeader_70 *unk70[1]; // unknown size, however only size of 1 matches
+      struct {
+  /* 0x70 */ u8 darkVertexColours; // always 1 except in Hot Top Volcano where it's 0
+  /* 0x71 */ u8 unk71; // possible values: 0,1
+      };
+  };
 
   /* 0x74 */ LevelHeader_70 *unk74[7];
 
diff --git a/src/menu.c b/src/menu.c
index fd517278..56d205c3 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -8279,12 +8279,12 @@ void menu_track_select_init(void) {
     }
     for (i = 0; i < 2; i++) {
         for (j = 0; j < 40; j++) {
-            gTrackSelectBgTriangles[i][j].flags = 0x40; // 0x40 = Draw backface
+            gTrackSelectBgTriangles[i][j].flags = BACKFACE_DRAW;
             gTrackSelectBgTriangles[i][j].vi0 = 0;
             gTrackSelectBgTriangles[i][j].vi1 = 2;
             gTrackSelectBgTriangles[i][j].vi2 = 1;
             j++;
-            gTrackSelectBgTriangles[i][j].flags = 0x40;
+            gTrackSelectBgTriangles[i][j].flags = BACKFACE_DRAW;
             gTrackSelectBgTriangles[i][j].vi0 = 1;
             gTrackSelectBgTriangles[i][j].vi1 = 2;
             gTrackSelectBgTriangles[i][j].vi2 = 3;
diff --git a/src/waves.c b/src/waves.c
index 1215ad03..0d69a83b 100644
--- a/src/waves.c
+++ b/src/waves.c
@@ -11,14 +11,13 @@
 
 /************ .data ************/
 
-f32 *D_800E3040 = NULL;
-Vec2s *D_800E3044 = NULL;
-Vec2s *D_800E3048 = NULL;
-f32 *D_800E304C[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+f32 *D_800E3040 = NULL;   // indexed by values of D_800E3044
+Vec2s *D_800E3044 = NULL; // holds some sort of index?
+TexCoords *D_800E3048 = NULL;
+f32 *D_800E304C[9] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 
-Vertex *D_800E3070[2] = { NULL, NULL };
-s32 *D_800E3078[2] = { NULL, NULL };
-Triangle *D_800E3080[4][1] = { NULL, NULL, NULL, NULL };
+Vertex *gWaveVertices[4] = { NULL, NULL };
+Triangle *gWaveTriangles[4][1] = { NULL, NULL, NULL, NULL };
 Triangle D_800E3090[4] = {
     { { BACKFACE_DRAW, 0x00, 0x02, 0x01 }, 0, 0, 0, 0, 0, 0 },
     { { BACKFACE_DRAW, 0x01, 0x02, 0x03 }, 0, 0, 0, 0, 0, 0 },
@@ -26,12 +25,12 @@ Triangle D_800E3090[4] = {
     { { BACKFACE_DRAW, 0x01, 0x02, 0x03 }, 0, 0, 0, 0, 0, 0 },
 };
 
-TextureHeader *D_800E30D0 = NULL;
-s32 *D_800E30D4 = NULL;
+TextureHeader *gWaveTextureHeader = NULL;
+s32 *D_800E30D4 = NULL; // indexed by D_800E30D8.unkC
 LevelModel_Alternate *D_800E30D8 = NULL;
 s32 D_800E30DC = 0;     // Tracks an index into D_8012A1E8
-s16 *D_800E30E0 = NULL; // Points to either D_800E30E8 or D_800E3110
-s16 *D_800E30E4 = NULL; // Points to either D_800E30FC or D_800E3144
+s16 *D_800E30E0 = NULL; // Points to either D_800E30E8 or D_800E3110 and is used for D_800E30D4
+s16 *D_800E30E4 = NULL; // Points to either D_800E30FC or D_800E3144 and is used to index D_800E304C
 
 s16 D_800E30E8[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 
@@ -42,13 +41,13 @@ s16 D_800E3110[26] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17
 s16 D_800E3144[26] = { 0, 1, 1, 1, 2, 3, 4, 4, 4, 5, 3, 4, 4, 4, 5, 3, 4, 4, 4, 5, 6, 7, 7, 7, 8, 0 };
 
 u8 *D_800E3178 = NULL;
-s32 D_800E317C = 0;
+s32 D_800E317C = 0; // some sort of count? Relative to D_80129FC8.unk0
 LevelHeader_70 *D_800E3180 = NULL;
-unk800E3184 *D_800E3184 = NULL;
-s32 D_800E3188 = 0;
-s32 D_800E318C = 0;
+unk800E3184 *D_800E3184 = NULL; // tracks an index into D_800E3190
+s32 D_800E3188 = 0;             // counter for something, incremented in func_800BF634, decremented in func_800BF3E4
+s32 D_800E318C = 0;             // used in mempool_alloc_safe size calculation, multiplied with 8
 unk800E3190 *D_800E3190 = NULL;
-Object **D_800E3194 = NULL;
+Object **D_800E3194 = NULL; // might be a length of 32
 Object *gWaveGeneratorObj = NULL;
 
 /*******************************/
@@ -65,43 +64,43 @@ const char D_800E9260[] = "\nError :: can not add another wave swell, reached li
 
 /************ .bss ************/
 
-Gfx *D_80129FC0;
-s32 D_80129FC4;
-unk80129FC8 D_80129FC8;
-s32 D_8012A018;
-f32 D_8012A01C;
-f32 D_8012A020;
+Gfx *gWaveDL;
+MatrixS *D_80129FC4;
+unk80129FC8 D_80129FC8; // holds lots of control information used in this file
+s32 D_8012A018;         // either 1 or 0, toggled in func_800B9C18, used to index vertices and triangles
+f32 D_8012A01C;         // is set to lowest value of D_800E3040
+f32 D_8012A020;         // is set to highest value of D_800E3040
 UNUSED s32 D_8012A024;
-Vertex D_8012A028[2][4];
-s32 D_8012A078;
+Vertex D_8012A028[2][4]; // stores values of gWaveVertices to be used in func_800BA8E4
+s32 D_8012A078;          // controls whether 2 or 4 items are used in gWaveVertices / gWaveTriangles
 TriangleBatchInfo *gWaveBatch;
 TextureHeader *gWaveTexture;
-s32 D_8012A084;
-s32 D_8012A088;
-s32 D_8012A08C;
-s32 D_8012A090;
-s32 D_8012A094;
-s32 D_8012A098;
-s32 D_8012A09C;
-f32 D_8012A0A0;
-f32 D_8012A0A4;
+s32 D_8012A084; // u value for D_800E3048
+s32 D_8012A088; // v value for D_800E3048
+s32 D_8012A08C; // is added onto u of D_8012A084, is multiplied with texture width
+s32 D_8012A090; // is added onto v of D_8012A084, is multiplied with texture height
+s32 D_8012A094; // bitmask / something width (related to texture)
+s32 D_8012A098; // bitmask / something height (related to texture)
+s32 D_8012A09C; // stores / relates to frameAdvanceDelay, used in func_800BA8E4
+f32 D_8012A0A0; // copy of gWaveBoundingBoxDiffX
+f32 D_8012A0A4; // copy of gWaveBoundingBoxDiffZ
 s32 gWaveBoundingBoxDiffX;
 s32 gWaveBoundingBoxDiffZ;
 s32 gWaveBoundingBoxX1;
 s32 gWaveBoundingBoxZ1;
-f32 D_8012A0B8;
-f32 D_8012A0BC;
-s32 D_8012A0C0;
-s32 D_8012A0C4;
-s32 D_8012A0C8;
-s32 D_8012A0CC;
-s32 D_8012A0D0;
-s32 D_8012A0D4;
-s32 D_8012A0D8;
-s32 D_8012A0DC;
+f32 D_8012A0B8; // some sort of ratio for x
+f32 D_8012A0BC; // some sort of ratio for z
+s32 D_8012A0C0; // level bounding box x1
+s32 D_8012A0C4; // level bounding box x2
+s32 D_8012A0C8; // level bounding box z1
+s32 D_8012A0CC; // level bounding box x2
+s32 D_8012A0D0; // copy of gWaveBoundingBoxX1
+s32 D_8012A0D4; // copy of gWaveBoundingBoxZ1
+s32 D_8012A0D8; // used in mempool_alloc_safe size calculation
+s32 D_8012A0DC; // used in mempool_alloc_safe size calculation
 s32 gNumberOfLevelSegments;
 s32 D_8012A0E8[64];
-s16 D_8012A1E8[512];
+s16 D_8012A1E8[512]; // used to index D_800E30D8 and as arg0 for func_800B92F4 and func_800B97A8
 
 typedef struct unk8012A5E8 {
     s16 unk0;
@@ -111,7 +110,9 @@ typedef struct unk8012A5E8 {
     s32 unk8;
 } unk8012A5E8;
 
+// This could be (and probably is) just a pointer
 unk8012A5E8 D_8012A5E8[1];
+// might be the same as D_8012A5E8
 s16 D_8012A5F4;
 UNUSED s32 D_8012A5F8;
 UNUSED s32 D_8012A5FC;
@@ -142,16 +143,16 @@ void free_waves(void) {
     FREE_MEM(D_800E3044);
     FREE_MEM(D_800E3048);
     FREE_MEM(D_800E304C[0]);
-    FREE_MEM(D_800E3070[0]);
-    FREE_MEM(D_800E3080[0][0]);
-    FREE_TEX(D_800E30D0);
+    FREE_MEM(gWaveVertices[0]);
+    FREE_MEM(gWaveTriangles[0][0]);
+    FREE_TEX(gWaveTextureHeader);
     FREE_MEM(D_800E30D4);
     FREE_MEM(D_800E30D8);
     FREE_MEM(D_800E3178);
     D_800E3190 = NULL;
     D_800E3194 = NULL;
     D_800E3184 = NULL;
-    D_800E3188 = NULL;
+    D_800E3188 = 0;
 }
 
 void wave_init(void) {
@@ -160,9 +161,10 @@ void wave_init(void) {
     s32 i;
 
     free_waves();
-    D_800E3040 = (f32 *) mempool_alloc_safe(D_80129FC8.unk20 << 2, COLOUR_TAG_CYAN);
-    D_800E3044 = (Vec2s *) mempool_alloc_safe((D_80129FC8.unk4 << 2) * D_80129FC8.unk4, COLOUR_TAG_CYAN);
-    D_800E3048 = (Vec2s *) mempool_alloc_safe(((D_80129FC8.unk0 + 1) << 2) * (D_80129FC8.unk0 + 1), COLOUR_TAG_CYAN);
+    D_800E3040 = (f32 *) mempool_alloc_safe(D_80129FC8.unk20 * sizeof(f32 *), COLOUR_TAG_CYAN);
+    D_800E3044 = (Vec2s *) mempool_alloc_safe((D_80129FC8.unk4 * sizeof(Vec2s *)) * D_80129FC8.unk4, COLOUR_TAG_CYAN);
+    D_800E3048 = (TexCoords *) mempool_alloc_safe(((D_80129FC8.unk0 + 1) * sizeof(TexCoords *)) * (D_80129FC8.unk0 + 1),
+                                                  COLOUR_TAG_CYAN);
     allocSize = ((D_80129FC8.unk0 + 1) << 2) * (D_80129FC8.unk0 + 1);
     D_800E304C[0] = mempool_alloc_safe(allocSize * ARRAY_COUNT(D_800E304C), COLOUR_TAG_CYAN);
     for (i = 1; i < ARRAY_COUNT(D_800E304C); i++) {
@@ -171,25 +173,25 @@ void wave_init(void) {
     temp = (D_80129FC8.unk0 + 1);
     allocSize = (temp * 250 * (D_80129FC8.unk0 + 1));
     if (D_8012A078 != 2) {
-        D_800E3070[0] = (Vertex *) mempool_alloc_safe(allocSize << 1, COLOUR_TAG_CYAN);
-        D_800E3070[1] = (Vertex *) (((u32) D_800E3070[0]) + allocSize);
+        gWaveVertices[0] = (Vertex *) mempool_alloc_safe(allocSize << 1, COLOUR_TAG_CYAN);
+        gWaveVertices[1] = (Vertex *) (((u32) gWaveVertices[0]) + allocSize);
     } else {
-        D_800E3070[0] = (Vertex *) mempool_alloc_safe(allocSize << 2, COLOUR_TAG_CYAN);
-        D_800E3070[1] = (Vertex *) (((u32) D_800E3070[0]) + allocSize);
-        D_800E3070[2] = (Vertex *) (((u32) D_800E3070[1]) + allocSize);
-        D_800E3070[3] = (Vertex *) (((u32) D_800E3070[2]) + allocSize);
+        gWaveVertices[0] = (Vertex *) mempool_alloc_safe(allocSize << 2, COLOUR_TAG_CYAN);
+        gWaveVertices[1] = (Vertex *) (((u32) gWaveVertices[0]) + allocSize);
+        gWaveVertices[2] = (Vertex *) (((u32) gWaveVertices[1]) + allocSize);
+        gWaveVertices[3] = (Vertex *) (((u32) gWaveVertices[2]) + allocSize);
     }
     allocSize = (D_80129FC8.unk0 * 32) * D_80129FC8.unk0;
     if (D_8012A078 != 2) {
-        D_800E3080[0][0] = mempool_alloc_safe(allocSize << 1, COLOUR_TAG_CYAN);
-        D_800E3080[1][0] = (Triangle *) (((u32) D_800E3080[0][0]) + allocSize);
+        gWaveTriangles[0][0] = mempool_alloc_safe(allocSize << 1, COLOUR_TAG_CYAN);
+        gWaveTriangles[1][0] = (Triangle *) (((u32) gWaveTriangles[0][0]) + allocSize);
     } else {
-        D_800E3080[0][0] = (Triangle *) mempool_alloc_safe(allocSize << 2, COLOUR_TAG_CYAN);
-        D_800E3080[1][0] = (Triangle *) (((u32) D_800E3080[0][0]) + allocSize);
-        D_800E3080[2][0] = (Triangle *) (((u32) D_800E3080[1][0]) + allocSize);
-        D_800E3080[3][0] = (Triangle *) (((u32) D_800E3080[2][0]) + allocSize);
+        gWaveTriangles[0][0] = (Triangle *) mempool_alloc_safe(allocSize << 2, COLOUR_TAG_CYAN);
+        gWaveTriangles[1][0] = (Triangle *) (((u32) gWaveTriangles[0][0]) + allocSize);
+        gWaveTriangles[2][0] = (Triangle *) (((u32) gWaveTriangles[1][0]) + allocSize);
+        gWaveTriangles[3][0] = (Triangle *) (((u32) gWaveTriangles[2][0]) + allocSize);
     }
-    D_800E30D0 = load_texture(D_80129FC8.unk2C);
+    gWaveTextureHeader = load_texture(D_80129FC8.textureId);
 }
 
 void func_800B8134(LevelHeader *header) {
@@ -212,7 +214,7 @@ void func_800B8134(LevelHeader *header) {
         D_80129FC8.unk24 = 3;
     }
     D_80129FC8.unk28 = header->unk71;
-    D_80129FC8.unk2C = header->unk68 & 0xFFFF;
+    D_80129FC8.textureId = header->textureId & 0xFFFF;
     D_80129FC8.unk30 = header->unk6A;
     D_80129FC8.unk34 = header->unk6B;
     D_80129FC8.unk38 = header->unk6C;
@@ -220,10 +222,10 @@ void func_800B8134(LevelHeader *header) {
     D_80129FC8.magnitude = header->wavePower / 256.0f;
     D_80129FC8.unk44 = header->unk64 / 256.0f;
     D_80129FC8.unk48 = header->unk66 / 256.0f;
-    D_80129FC8.unk4C = header->unk70_u8;
+    D_80129FC8.darkVertexColours = header->darkVertexColours;
 }
 
-void func_800B82B4(LevelModel *arg0, LevelHeader *arg1, s32 arg2) {
+void func_800B82B4(LevelModel *model, LevelHeader *header, s32 arg2) {
     s32 k;
     s32 var_fp;
     s32 j_2;
@@ -242,11 +244,11 @@ void func_800B82B4(LevelModel *arg0, LevelHeader *arg1, s32 arg2) {
     s32 var_t2;
 
     D_8012A078 = arg2;
-    func_800B8134(arg1);
+    func_800B8134(header);
     wave_init();
-    func_800BBDDC(arg0, arg1);
-    D_8012A0A0 = (f32) gWaveBoundingBoxDiffX;
-    D_8012A0A4 = (f32) gWaveBoundingBoxDiffZ;
+    func_800BBDDC(model, header);
+    D_8012A0A0 = gWaveBoundingBoxDiffX;
+    D_8012A0A4 = gWaveBoundingBoxDiffZ;
     D_8012A0B8 = D_8012A0A0 / D_80129FC8.unk0;
     D_8012A0BC = D_8012A0A4 / D_80129FC8.unk0;
     D_8012A084 = 0;
@@ -264,7 +266,7 @@ void func_800B82B4(LevelModel *arg0, LevelHeader *arg1, s32 arg2) {
     D_8012A020 = -10000.0f;
     for (i_2 = 0; i_2 < D_80129FC8.unk20; i_2++) {
         D_800E3040[i_2] = (sins_f(var_s6) * D_80129FC8.unkC) + (sins_f(var_fp) * D_80129FC8.unk18);
-        if (D_80129FC8.unk28 != 0) {
+        if (D_80129FC8.unk28 != FALSE) {
             D_800E3040[i_2] *= 2.0f;
         }
         if (D_800E3040[i_2] < D_8012A01C) {
@@ -300,18 +302,19 @@ void func_800B82B4(LevelModel *arg0, LevelHeader *arg1, s32 arg2) {
             do {
                 for (j_2 = 0; D_80129FC8.unk0 >= j_2; j_2++) {
                     for (k = 0; k < arg2; k++) {
-                        D_800E3070[k][var_s5].x = (j_2 * D_8012A0B8) + 0.5;
-                        D_800E3070[k][var_s5].z = (i_2 * D_8012A0BC) + 0.5;
-                        if (D_80129FC8.unk4C == 0) {
-                            D_800E3070[k][var_s5].r = 255;
-                            D_800E3070[k][var_s5].g = 255;
-                            D_800E3070[k][var_s5].b = 255;
+                        gWaveVertices[k][var_s5].x = (j_2 * D_8012A0B8) + 0.5;
+                        gWaveVertices[k][var_s5].z = (i_2 * D_8012A0BC) + 0.5;
+                        // this is only 0 for hot top volcano
+                        if (D_80129FC8.darkVertexColours == 0) {
+                            gWaveVertices[k][var_s5].r = 255;
+                            gWaveVertices[k][var_s5].g = 255;
+                            gWaveVertices[k][var_s5].b = 255;
                         } else {
-                            D_800E3070[k][var_s5].r = 0;
-                            D_800E3070[k][var_s5].g = 0;
-                            D_800E3070[k][var_s5].b = 0;
+                            gWaveVertices[k][var_s5].r = 0;
+                            gWaveVertices[k][var_s5].g = 0;
+                            gWaveVertices[k][var_s5].b = 0;
                         }
-                        D_800E3070[k][var_s5].a = 255;
+                        gWaveVertices[k][var_s5].a = 255;
                     }
                     var_s5++;
                 }
@@ -325,15 +328,15 @@ void func_800B82B4(LevelModel *arg0, LevelHeader *arg1, s32 arg2) {
     for (i_2 = 0; i_2 < D_80129FC8.unk0; i_2++) {
         for (j_2 = 0; j_2 < D_80129FC8.unk0; j_2++) {
             for (k = 0; k < arg2; k++) {
-                D_800E3080[0][k][var_s5].flags = BACKFACE_DRAW;
-                D_800E3080[0][k][var_s5].vi0 = j_2;
-                D_800E3080[0][k][var_s5].vi1 = (j_2 + D_80129FC8.unk0) + 1;
-                D_800E3080[0][k][var_s5].vi2 = j_2 + 1;
+                gWaveTriangles[0][k][var_s5].flags = BACKFACE_DRAW;
+                gWaveTriangles[0][k][var_s5].vi0 = j_2;
+                gWaveTriangles[0][k][var_s5].vi1 = (j_2 + D_80129FC8.unk0) + 1;
+                gWaveTriangles[0][k][var_s5].vi2 = j_2 + 1;
                 var_s5++;
-                D_800E3080[0][k][var_s5].flags = BACKFACE_DRAW;
-                D_800E3080[0][k][var_s5].vi0 = j_2 + 1;
-                D_800E3080[0][k][var_s5].vi1 = (j_2 + D_80129FC8.unk0) + 1;
-                D_800E3080[0][k][var_s5].vi2 = (j_2 + D_80129FC8.unk0) + 2;
+                gWaveTriangles[0][k][var_s5].flags = BACKFACE_DRAW;
+                gWaveTriangles[0][k][var_s5].vi0 = j_2 + 1;
+                gWaveTriangles[0][k][var_s5].vi1 = (j_2 + D_80129FC8.unk0) + 1;
+                gWaveTriangles[0][k][var_s5].vi2 = (j_2 + D_80129FC8.unk0) + 2;
                 var_s5--;
             }
             var_s5 += 2;
@@ -342,41 +345,41 @@ void func_800B82B4(LevelModel *arg0, LevelHeader *arg1, s32 arg2) {
     func_800BC6C8();
 
     var_s5 = (D_80129FC8.unk0 + 1) * D_80129FC8.unk0;
-    for (i = 0; i < ARRAY_COUNT(D_800E3070); i++) {
-        D_8012A028[i][0].x = D_800E3070[i][0].x;
+    for (i = 0; i < ARRAY_COUNT(D_8012A028); i++) {
+        D_8012A028[i][0].x = gWaveVertices[i][0].x;
         D_8012A028[i][0].y = 0;
-        D_8012A028[i][0].z = D_800E3070[i][0].z;
-        D_8012A028[i][0].r = D_800E3070[i][0].r;
-        D_8012A028[i][0].g = D_800E3070[i][0].g;
-        D_8012A028[i][0].b = D_800E3070[i][0].b;
-        D_8012A028[i][0].a = D_800E3070[i][0].a;
+        D_8012A028[i][0].z = gWaveVertices[i][0].z;
+        D_8012A028[i][0].r = gWaveVertices[i][0].r;
+        D_8012A028[i][0].g = gWaveVertices[i][0].g;
+        D_8012A028[i][0].b = gWaveVertices[i][0].b;
+        D_8012A028[i][0].a = gWaveVertices[i][0].a;
 
-        D_8012A028[i][1].x = D_800E3070[i][D_80129FC8.unk0].x;
+        D_8012A028[i][1].x = gWaveVertices[i][D_80129FC8.unk0].x;
         D_8012A028[i][1].y = 0;
-        D_8012A028[i][1].z = D_800E3070[i][D_80129FC8.unk0].z;
-        D_8012A028[i][1].r = D_800E3070[i][D_80129FC8.unk0].r;
-        D_8012A028[i][1].g = D_800E3070[i][D_80129FC8.unk0].g;
-        D_8012A028[i][1].b = D_800E3070[i][D_80129FC8.unk0].b;
-        D_8012A028[i][1].a = D_800E3070[i][D_80129FC8.unk0].a;
+        D_8012A028[i][1].z = gWaveVertices[i][D_80129FC8.unk0].z;
+        D_8012A028[i][1].r = gWaveVertices[i][D_80129FC8.unk0].r;
+        D_8012A028[i][1].g = gWaveVertices[i][D_80129FC8.unk0].g;
+        D_8012A028[i][1].b = gWaveVertices[i][D_80129FC8.unk0].b;
+        D_8012A028[i][1].a = gWaveVertices[i][D_80129FC8.unk0].a;
 
-        D_8012A028[i][2].x = D_800E3070[i][var_s5].x;
+        D_8012A028[i][2].x = gWaveVertices[i][var_s5].x;
         D_8012A028[i][2].y = 0;
-        D_8012A028[i][2].z = D_800E3070[i][var_s5].z;
-        D_8012A028[i][2].r = D_800E3070[i][var_s5].r;
-        D_8012A028[i][2].g = D_800E3070[i][var_s5].g;
-        D_8012A028[i][2].b = D_800E3070[i][var_s5].b;
-        D_8012A028[i][2].a = D_800E3070[i][var_s5].a;
+        D_8012A028[i][2].z = gWaveVertices[i][var_s5].z;
+        D_8012A028[i][2].r = gWaveVertices[i][var_s5].r;
+        D_8012A028[i][2].g = gWaveVertices[i][var_s5].g;
+        D_8012A028[i][2].b = gWaveVertices[i][var_s5].b;
+        D_8012A028[i][2].a = gWaveVertices[i][var_s5].a;
 
-        D_8012A028[i][3].x = D_800E3070[i][var_s5 + D_80129FC8.unk0].x;
+        D_8012A028[i][3].x = gWaveVertices[i][var_s5 + D_80129FC8.unk0].x;
         D_8012A028[i][3].y = 0;
-        D_8012A028[i][3].z = D_800E3070[i][var_s5 + D_80129FC8.unk0].z;
-        D_8012A028[i][3].r = D_800E3070[i][var_s5 + D_80129FC8.unk0].r;
-        D_8012A028[i][3].g = D_800E3070[i][var_s5 + D_80129FC8.unk0].g;
-        D_8012A028[i][3].b = D_800E3070[i][var_s5 + D_80129FC8.unk0].b;
-        D_8012A028[i][3].a = D_800E3070[i][var_s5 + D_80129FC8.unk0].a;
+        D_8012A028[i][3].z = gWaveVertices[i][var_s5 + D_80129FC8.unk0].z;
+        D_8012A028[i][3].r = gWaveVertices[i][var_s5 + D_80129FC8.unk0].r;
+        D_8012A028[i][3].g = gWaveVertices[i][var_s5 + D_80129FC8.unk0].g;
+        D_8012A028[i][3].b = gWaveVertices[i][var_s5 + D_80129FC8.unk0].b;
+        D_8012A028[i][3].a = gWaveVertices[i][var_s5 + D_80129FC8.unk0].a;
     }
 
-    func_800BCC70(arg0);
+    func_800BCC70(model);
     if (D_80129FC8.unk24 == 3) {
         D_800E30E0 = D_800E30E8;
         D_800E30E4 = D_800E30FC;
@@ -392,17 +395,11 @@ void func_800B82B4(LevelModel *arg0, LevelHeader *arg1, s32 arg2) {
 }
 
 void func_800B8B8C(void) {
-    s32 temp_v0;
-    s32 phi_v0;
     s32 i;
 
     D_800E30DC = 0;
-    phi_v0 = 0;
-
     for (i = 0; i < D_8012A0D8 * D_8012A0DC; i++) {
-        temp_v0 = phi_v0 + 1;
         D_800E30D4[i] = 0;
-        phi_v0 = temp_v0;
     }
 }
 
@@ -429,11 +426,7 @@ void func_800B8C04(s32 xPosition, s32 yPosition, s32 zPosition, s32 currentViewp
     D_8012A5E8[0].unk0 = -1;
     D_8012A5F4 = -1;
 
-    // This is incorrect because the assembly compares
-    // var_v1 != gWavePowerBase
-    // however gWavePowerBase is a f32
-    // so instead we (for now) set every 6th values in the struct to -1
-    // D_8012A600 seems unused anyway though
+    // D_8012A600 seems to be unused
     for (var_v1 = 0; var_v1 < 144; var_v1 += 24) {
         D_8012A600[var_v1] = -1;
         D_8012A600[var_v1 + 6] = -1;
@@ -441,7 +434,7 @@ void func_800B8C04(s32 xPosition, s32 yPosition, s32 zPosition, s32 currentViewp
         D_8012A600[var_v1 + 18] = -1;
     }
 
-    if (D_80129FC8.unk28 != 0) {
+    if (D_80129FC8.unk28 != FALSE) {
         var_t5 = gWaveBoundingBoxDiffZ;
         var_v1 = 0;
         var_s4 = 0;
@@ -574,7 +567,7 @@ void func_800B92F4(s32 arg0, s32 arg1) {
     s32 var_s2;
     s32 j;
     f32 temp_f22;
-    f32 var_f20;
+    f32 vertexY;
     s32 sp98;
     s32 var_v0;
     s32 sp90;
@@ -596,7 +589,7 @@ void func_800B92F4(s32 arg0, s32 arg1) {
             continue;
         }
 
-        if (D_80129FC8.unk28 != 0) {
+        if (D_80129FC8.unk28 != FALSE) {
             sp98 = (((u32) D_800E30D4[sp6C->unkC] >> (D_8012A5E8[k].unk2 * 8)) & 0xFF) - 1;
             sp8C = (D_8012A5E8[k].unk2 & 1) * D_80129FC8.unk0;
             sp88 = ((D_8012A5E8[k].unk2 & 2) >> 1) * D_80129FC8.unk0;
@@ -607,19 +600,19 @@ void func_800B92F4(s32 arg0, s32 arg1) {
         }
 
         sp84 = D_8012A5E8[k].unk6;
-        vertices = &D_800E3070[D_8012A018 + arg1][sp90 * sp98];
+        vertices = &gWaveVertices[D_8012A018 + arg1][sp90 * sp98];
         sp98 = D_800E30E4[sp98];
         vertexIdx = 0;
         for (i = 0; i <= D_80129FC8.unk0; i++) {
             var_s1 = D_8012A5E8[k].unk4;
             var_s2 = (sp84 * D_80129FC8.unk4) + var_s1;
             for (j = 0; j <= D_80129FC8.unk0; j++) {
-                var_f20 =
+                vertexY =
                     (D_800E3040[D_800E3044[var_s2].s[0]] + D_800E3040[D_800E3044[var_s2].s[1]]) * D_80129FC8.magnitude;
                 if (D_800E3188 > 0) {
-                    var_f20 += func_800BEFC4(arg0, j + sp8C, i + sp88);
+                    vertexY += func_800BEFC4(arg0, j + sp8C, i + sp88);
                 }
-                var_f20 *= D_800E304C[sp98][vertexIdx];
+                vertexY *= D_800E304C[sp98][vertexIdx];
                 var_v0 = D_800E3178[D_8012A5E8[k].unk8];
 
                 // clang-format off
@@ -627,29 +620,23 @@ void func_800B92F4(s32 arg0, s32 arg1) {
                 D_8012A5E8[k].unk8++;
                 // clang-format on
                 if (var_v0 < 0xFF) {
-                    var_f20 *= D_80129FC8.unk44 + ((f32) var_v0 * temp_f22);
+                    vertexY *= D_80129FC8.unk44 + ((f32) var_v0 * temp_f22);
                 }
-                var_v0 += (s32) (var_f20 * D_80129FC8.unk48);
-                if (var_v0 >= 0x100) {
+                var_v0 += (s32) (vertexY * D_80129FC8.unk48);
+                if (var_v0 > 0xFF) {
                     var_v0 = 0xFF;
                 } else if (var_v0 < 0) {
                     var_v0 = 0;
                 }
                 var_v0 += ((0xFF - var_v0) * sp6C->unk14[arg1 >> 1].unk0[D_8012A5E8[k].unk2]) >> 7;
-                vertices[vertexIdx].y = var_f20;
-                if (var_v0 < 0xC0) {
-                    var_v1 = 0xFF;
-                } else {
-                    var_v1 = ((0xFF - var_v0) * 4) & 0xFF;
-                }
+                vertices[vertexIdx].y = vertexY;
+
+                var_v1 = var_v0 < 0xC0 ? 0xFF : ((0xFF - var_v0) * 4) & 0xFF;
                 vertices[vertexIdx].r = var_v1;
                 vertices[vertexIdx].g = var_v1;
                 vertices[vertexIdx].b = var_v1;
-                if (var_v0 < 0x40) {
-                    var_v1 = (var_v0 * 4) & 0xFF;
-                } else {
-                    var_v1 = 0xFF;
-                }
+
+                var_v1 = var_v0 < 0x40 ? (var_v0 * 4) & 0xFF : 0xFF;
                 vertices[vertexIdx].a = var_v1;
                 vertexIdx++;
                 var_s1++;
@@ -663,7 +650,7 @@ void func_800B92F4(s32 arg0, s32 arg1) {
             if (sp84 >= D_80129FC8.unk4) {
                 sp84 -= D_80129FC8.unk4;
             }
-            if (D_80129FC8.unk28 != 0) {
+            if (D_80129FC8.unk28 != FALSE) {
                 D_8012A5E8[k].unk8 += D_80129FC8.unk0;
             }
         }
@@ -690,14 +677,10 @@ void func_800B97A8(s32 arg0, s32 arg1) {
     s32 k;
 
     k = 0;
-    temp_f26 = D_8012A020 * 2.0f - D_8012A01C * 2.0f;
+    temp_f26 = (D_8012A020 * 2.0f) - (D_8012A01C * 2.0f);
     spA0 = (D_80129FC8.unk0 + 1) * (D_80129FC8.unk0 + 1);
     sp78 = &D_800E30D8[arg0];
-    if (temp_f26 <= 0) {
-        var_f28 = 0;
-    } else {
-        var_f28 = 1.0f / temp_f26;
-    }
+    var_f28 = temp_f26 <= 0 ? 0 : 1.0f / temp_f26;
 
     temp_f26 = D_8012A01C * 2.0f;
     for (; D_8012A5E8[k].unk0 != -1; k++) {
@@ -705,7 +688,7 @@ void func_800B97A8(s32 arg0, s32 arg1) {
             continue;
         }
 
-        if (D_80129FC8.unk28 != 0) {
+        if (D_80129FC8.unk28 != FALSE) {
             spA8 = (((u32) D_800E30D4[sp78->unkC] >> (D_8012A5E8[k].unk2 * 8)) & 0xFF) - 1;
             sp9C = (D_8012A5E8[k].unk2 & 1) * D_80129FC8.unk0;
             sp98 = ((s32) (D_8012A5E8[k].unk2 & 2) >> 1) * D_80129FC8.unk0;
@@ -716,11 +699,9 @@ void func_800B97A8(s32 arg0, s32 arg1) {
         }
 
         var_a0 = D_8012A5E8[k].unk6;
-        vertices = &D_800E3070[D_8012A018 + arg1][spA0 * spA8];
+        vertices = &gWaveVertices[D_8012A018 + arg1][spA0 * spA8];
         spA8 = D_800E30E4[spA8];
-        i = 0;
-        vertexIdx = 0;
-        for (; i <= D_80129FC8.unk0; i++) {
+        for (i = 0, vertexIdx = 0; i <= D_80129FC8.unk0; i++) {
             var_s1 = D_8012A5E8[k].unk4;
             var_s2 = (var_a0 * D_80129FC8.unk4) + var_s1;
             for (j = 0; j <= D_80129FC8.unk0; j++) {
@@ -755,7 +736,7 @@ void func_800B97A8(s32 arg0, s32 arg1) {
             if (var_a0 >= D_80129FC8.unk4) {
                 var_a0 -= D_80129FC8.unk4;
             }
-            if (D_80129FC8.unk28 != 0) {
+            if (D_80129FC8.unk28 != FALSE) {
                 D_8012A5E8[k].unk8 += D_80129FC8.unk0;
             }
         }
@@ -772,31 +753,31 @@ void func_800B9C18(s32 arg0) {
     s32 var_t5;
     s32 var_t2;
     s32 var_s0;
-    s32 var_a3;
-    s32 pad;
-    s32 pad2;
+    s32 k_2;
+    s32 j_2;
+    s32 i_2;
 
     D_8012A018 = 1 - D_8012A018;
-    for (pad2 = 0, pad = 0; pad2 < D_80129FC8.unk4; pad2++) {
-        for (var_a3 = 0; var_a3 < D_80129FC8.unk4; var_a3++) {
-            D_800E3044[pad].s[0] += arg0;
-            while (D_800E3044[pad].s[0] >= D_80129FC8.unk20) {
-                D_800E3044[pad].s[0] -= D_80129FC8.unk20;
+    for (i_2 = 0, j_2 = 0; i_2 < D_80129FC8.unk4; i_2++) {
+        for (k_2 = 0; k_2 < D_80129FC8.unk4; k_2++) {
+            D_800E3044[j_2].s[0] += arg0;
+            while (D_800E3044[j_2].s[0] >= D_80129FC8.unk20) {
+                D_800E3044[j_2].s[0] -= D_80129FC8.unk20;
             }
-            D_800E3044[pad].s[1] += arg0;
-            while (D_800E3044[pad].s[1] >= D_80129FC8.unk20) {
-                D_800E3044[pad].s[1] -= D_80129FC8.unk20;
+            D_800E3044[j_2].s[1] += arg0;
+            while (D_800E3044[j_2].s[1] >= D_80129FC8.unk20) {
+                D_800E3044[j_2].s[1] -= D_80129FC8.unk20;
             }
-            pad++;
+            j_2++;
         }
     }
 
-    D_8012A09C += D_800E30D0->frameAdvanceDelay * arg0;
+    D_8012A09C += gWaveTextureHeader->frameAdvanceDelay * arg0;
     if (D_8012A09C < 0) {
         D_8012A09C = 0;
     } else {
-        while (D_8012A09C >= D_800E30D0->numOfTextures) {
-            D_8012A09C -= D_800E30D0->numOfTextures;
+        while (D_8012A09C >= gWaveTextureHeader->numOfTextures) {
+            D_8012A09C -= gWaveTextureHeader->numOfTextures;
         }
     }
 
@@ -806,8 +787,8 @@ void func_800B9C18(s32 arg0) {
     for (i = 0, var_s0 = 0; i <= D_80129FC8.unk0; i++) {
         var_v1 = D_8012A084;
         for (j = 0; j <= D_80129FC8.unk0; j++) {
-            D_800E3048[var_s0].s[0] = var_v1;
-            D_800E3048[var_s0].s[1] = var_a2;
+            D_800E3048[var_s0].u = var_v1;
+            D_800E3048[var_s0].v = var_a2;
             var_v1 += D_8012A08C;
             var_s0 += 1;
         }
@@ -826,18 +807,18 @@ void func_800B9C18(s32 arg0) {
     for (i = 0; i < D_80129FC8.unk0; i++) {
         for (j = 0; j < D_80129FC8.unk0; j++) {
             for (k = 0; k < var_t2; k++) {
-                D_800E3080[D_8012A018][k << 1][var_s0].uv0.u = D_800E3048[var_t5].s[0];
-                D_800E3080[D_8012A018][k << 1][var_s0].uv0.v = D_800E3048[var_t5 + 1].s[1];
-                D_800E3080[D_8012A018][k << 1][var_s0].uv1.u = D_800E3048[var_ra].s[0];
-                D_800E3080[D_8012A018][k << 1][var_s0].uv1.v = D_800E3048[var_ra].s[1];
-                D_800E3080[D_8012A018][k << 1][var_s0].uv2.u = D_800E3048[var_t5 + 1].s[0];
-                D_800E3080[D_8012A018][k << 1][var_s0].uv2.v = D_800E3048[var_t5 + 1].s[1];
-                D_800E3080[D_8012A018][k << 1][var_s0 + 1].uv0.u = D_800E3048[var_t5 + 1].s[0];
-                D_800E3080[D_8012A018][k << 1][var_s0 + 1].uv0.v = D_800E3048[var_t5 + 1].s[1];
-                D_800E3080[D_8012A018][k << 1][var_s0 + 1].uv1.u = D_800E3048[var_ra].s[0];
-                D_800E3080[D_8012A018][k << 1][var_s0 + 1].uv1.v = D_800E3048[var_ra + 1].s[1];
-                D_800E3080[D_8012A018][k << 1][var_s0 + 1].uv2.u = D_800E3048[var_ra + 1].s[0];
-                D_800E3080[D_8012A018][k << 1][var_s0 + 1].uv2.v = D_800E3048[var_ra + 1].s[1];
+                gWaveTriangles[D_8012A018][k << 1][var_s0].uv0.u = D_800E3048[var_t5].u;
+                gWaveTriangles[D_8012A018][k << 1][var_s0].uv0.v = D_800E3048[var_t5 + 1].v;
+                gWaveTriangles[D_8012A018][k << 1][var_s0].uv1.u = D_800E3048[var_ra].u;
+                gWaveTriangles[D_8012A018][k << 1][var_s0].uv1.v = D_800E3048[var_ra].v;
+                gWaveTriangles[D_8012A018][k << 1][var_s0].uv2.u = D_800E3048[var_t5 + 1].u;
+                gWaveTriangles[D_8012A018][k << 1][var_s0].uv2.v = D_800E3048[var_t5 + 1].v;
+                gWaveTriangles[D_8012A018][k << 1][var_s0 + 1].uv0.u = D_800E3048[var_t5 + 1].u;
+                gWaveTriangles[D_8012A018][k << 1][var_s0 + 1].uv0.v = D_800E3048[var_t5 + 1].v;
+                gWaveTriangles[D_8012A018][k << 1][var_s0 + 1].uv1.u = D_800E3048[var_ra].u;
+                gWaveTriangles[D_8012A018][k << 1][var_s0 + 1].uv1.v = D_800E3048[var_ra + 1].v;
+                gWaveTriangles[D_8012A018][k << 1][var_s0 + 1].uv2.u = D_800E3048[var_ra + 1].u;
+                gWaveTriangles[D_8012A018][k << 1][var_s0 + 1].uv2.v = D_800E3048[var_ra + 1].v;
             }
             var_t5++;
             var_ra++;
@@ -847,29 +828,31 @@ void func_800B9C18(s32 arg0) {
         var_ra++;
     }
 
-    D_800E3090[2 * D_8012A018].uv0.u = D_800E3048[0].s[0];
-    D_800E3090[2 * D_8012A018].uv0.v = D_800E3048[0].s[1];
-    D_800E3090[2 * D_8012A018].uv1.u = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1)].s[0];
-    D_800E3090[2 * D_8012A018].uv1.v = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1)].s[1];
-    D_800E3090[2 * D_8012A018].uv2.u = D_800E3048[D_80129FC8.unk0].s[0];
-    D_800E3090[2 * D_8012A018].uv2.v = D_800E3048[D_80129FC8.unk0].s[1];
-    D_800E3090[2 * D_8012A018 + 1].uv0.u = D_800E3048[D_80129FC8.unk0].s[0];
-    D_800E3090[2 * D_8012A018 + 1].uv0.v = D_800E3048[D_80129FC8.unk0].s[1];
-    D_800E3090[2 * D_8012A018 + 1].uv1.u = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1)].s[0];
-    D_800E3090[2 * D_8012A018 + 1].uv1.v = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1)].s[1];
-    D_800E3090[2 * D_8012A018 + 1].uv2.u = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1) + D_80129FC8.unk0].s[0];
-    D_800E3090[2 * D_8012A018 + 1].uv2.v = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1) + D_80129FC8.unk0].s[1];
+    D_800E3090[2 * D_8012A018].uv0.u = D_800E3048[0].u;
+    D_800E3090[2 * D_8012A018].uv0.v = D_800E3048[0].v;
+    D_800E3090[2 * D_8012A018].uv1.u = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1)].u;
+    D_800E3090[2 * D_8012A018].uv1.v = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1)].v;
+    D_800E3090[2 * D_8012A018].uv2.u = D_800E3048[D_80129FC8.unk0].u;
+    D_800E3090[2 * D_8012A018].uv2.v = D_800E3048[D_80129FC8.unk0].v;
+    D_800E3090[2 * D_8012A018 + 1].uv0.u = D_800E3048[D_80129FC8.unk0].u;
+    D_800E3090[2 * D_8012A018 + 1].uv0.v = D_800E3048[D_80129FC8.unk0].v;
+    D_800E3090[2 * D_8012A018 + 1].uv1.u = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1)].u;
+    D_800E3090[2 * D_8012A018 + 1].uv1.v = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1)].v;
+    D_800E3090[2 * D_8012A018 + 1].uv2.u = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1) + D_80129FC8.unk0].u;
+    D_800E3090[2 * D_8012A018 + 1].uv2.v = D_800E3048[D_80129FC8.unk0 * (D_80129FC8.unk0 + 1) + D_80129FC8.unk0].v;
 
     if (D_800E3188 > 0) {
         func_800BFE98(arg0);
     }
 
-    if (gWavePowerDivisor > 0) {
-        if (arg0 < gWavePowerDivisor) {
-            D_80129FC8.magnitude += (f32) arg0 * gWaveMagnitude;
-            gWavePowerDivisor -= arg0;
-            return;
-        }
+    if (gWavePowerDivisor <= 0) {
+        return;
+    }
+
+    if (arg0 < gWavePowerDivisor) {
+        D_80129FC8.magnitude += (f32) arg0 * gWaveMagnitude;
+        gWavePowerDivisor -= arg0;
+    } else {
         D_80129FC8.magnitude = gWavePowerBase;
         gWavePowerDivisor = 0;
     }
@@ -882,20 +865,19 @@ void func_800BA288(s32 arg0, s32 arg1) {
     arg1 <<= 3;
     for (i = 0; i < gNumberOfLevelSegments; i++) {
         if (D_8012A0E8[D_800E30D8[i].unkB] & (1 << D_800E30D8[i].unkA)) {
-            if (D_80129FC8.unk28 != 0) {
+            if (D_80129FC8.unk28 != FALSE) {
                 for (j = 0; j < 4; j++) {
-                    s32 ti = j << 3;
-                    if (D_800E30D4[D_800E30D8[i].unkC] & (0xFF << ti)) {
+                    if (D_800E30D4[D_800E30D8[i].unkC] & (0xFF << (j << 3))) {
                         if (arg1 < D_800E30D8[i].unk14[arg0].unk0[j]) {
                             D_800E30D8[i].unk14[arg0].unk0[j] -= arg1;
                         } else {
                             D_800E30D8[i].unk14[arg0].unk0[j] = 0;
                         }
                     } else {
-                        if (D_800E30D8[i].unk14[arg0].unk0[j] + arg1 < 128) {
+                        if ((D_800E30D8[i].unk14[arg0].unk0[j] + arg1) < 0x80) {
                             D_800E30D8[i].unk14[arg0].unk0[j] += arg1;
                         } else {
-                            D_800E30D8[i].unk14[arg0].unk0[j] = 128;
+                            D_800E30D8[i].unk14[arg0].unk0[j] = 0x80;
                         }
                     }
                 }
@@ -907,10 +889,10 @@ void func_800BA288(s32 arg0, s32 arg1) {
                         D_800E30D8[i].unk14[arg0].unk0[0] = 0;
                     }
                 } else {
-                    if (D_800E30D8[i].unk14[arg0].unk0[0] + arg1 < 128) {
+                    if (D_800E30D8[i].unk14[arg0].unk0[0] + arg1 < 0x80) {
                         D_800E30D8[i].unk14[arg0].unk0[0] += arg1;
                     } else {
-                        D_800E30D8[i].unk14[arg0].unk0[0] = 128;
+                        D_800E30D8[i].unk14[arg0].unk0[0] = 0x80;
                     }
                 }
             }
@@ -918,40 +900,40 @@ void func_800BA288(s32 arg0, s32 arg1) {
     }
 }
 
-void func_800BA4B8(TextureHeader *tex, s32 arg1) {
-    s32 sp5C;
-    s32 var_a2;
+void func_800BA4B8(TextureHeader *tex, s32 rtile) {
+    s32 mask;
+    s32 tmem;
     u32 texWidth;
 
     texWidth = tex->width;
-    var_a2 = 0;
+    tmem = 0;
     if (texWidth == 16) {
-        if (arg1 != 0) {
-            var_a2 = 384; // 0x180
+        if (rtile != 0) {
+            tmem = 384; // 0x180
         }
-        sp5C = 4;
+        mask = 4;
     } else if (texWidth == 32) {
-        sp5C = 5;
-        if (arg1 != 0) {
-            var_a2 = 256; // 0x100
+        mask = 5;
+        if (rtile != 0) {
+            tmem = 256; // 0x100
         }
     } else {
         texWidth = 3;
-        if (arg1 != 0) {
-            var_a2 = 384; // 0x180
+        if (rtile != 0) {
+            tmem = 384; // 0x180
         }
     }
 
     // difference is G_IM_SIZ_32b vs G_IM_SIZ_16b
     if ((tex->format & 0xF) == TEX_FORMAT_RGBA32) {
-        gDPLoadMultiBlock(D_80129FC0++, OS_PHYSICAL_TO_K0(tex + 1), var_a2, arg1, G_IM_FMT_RGBA, G_IM_SIZ_32b, texWidth,
-                          texWidth, 0, 0, 0, sp5C, sp5C, 0, 0);
+        gDPLoadMultiBlock(gWaveDL++, OS_PHYSICAL_TO_K0(tex + 1), tmem, rtile, G_IM_FMT_RGBA, G_IM_SIZ_32b, texWidth,
+                          texWidth, 0, 0, 0, mask, mask, 0, 0);
 
         return;
     }
 
-    gDPLoadMultiBlock(D_80129FC0++, OS_PHYSICAL_TO_K0(tex + 1), var_a2, arg1, G_IM_FMT_RGBA, G_IM_SIZ_16b, texWidth,
-                      texWidth, 0, 0, 0, sp5C, sp5C, 0, 0);
+    gDPLoadMultiBlock(gWaveDL++, OS_PHYSICAL_TO_K0(tex + 1), tmem, rtile, G_IM_FMT_RGBA, G_IM_SIZ_16b, texWidth,
+                      texWidth, 0, 0, 0, mask, mask, 0, 0);
 }
 
 // https://decomp.me/scratch/9b2EF
@@ -966,8 +948,8 @@ f32 func_800BB2F4(s32 arg0, f32 arg1, f32 arg2, Vec3f *arg3) {
     f32 sp90;
     f32 var_f16;
     f32 arg3X;
-    f32 arg3Z;
     f32 arg3Y;
+    f32 arg3Z;
     s32 var_a0;
     f32 sp78;
     s32 var_v0;
@@ -991,7 +973,7 @@ f32 func_800BB2F4(s32 arg0, f32 arg1, f32 arg2, Vec3f *arg3) {
     var_f16 = (1.0f - D_80129FC8.unk44) / 127.0f;
     sp58 = arg0 * D_800E317C;
 
-    if (D_80129FC8.unk28 != 0) {
+    if (D_80129FC8.unk28 != FALSE) {
         sp90 *= 0.5f;
         sp94 *= 0.5f;
         sp60 = (D_80129FC8.unk0 * 2) + 1;
@@ -1057,8 +1039,11 @@ f32 func_800BB2F4(s32 arg0, f32 arg1, f32 arg2, Vec3f *arg3) {
             var_f12 *= D_80129FC8.unk44 + (var_v0 * var_f16);
         }
 
-        var_a0 =
-            (var_t0 + 1) >= D_80129FC8.unk4 ? var_a3 * D_80129FC8.unk4 : (var_t0 + 0) + var_a3 * D_80129FC8.unk4 + 1;
+        if ((var_t0 + 1) >= D_80129FC8.unk4) {
+            var_a0 = var_a3 * D_80129FC8.unk4;
+        } else {
+            var_a0 = (var_t0 + 0) + (var_a3 * D_80129FC8.unk4) + 1;
+        }
         var_f2 = (D_800E3040[D_800E3044[var_a0].s[0]] + D_800E3040[D_800E3044[var_a0].s[1]]) * D_80129FC8.magnitude;
         if (D_800E3188 > 0) {
             var_f2 += func_800BEFC4(arg0, sp70 + 1, sp6C);
@@ -1070,7 +1055,7 @@ f32 func_800BB2F4(s32 arg0, f32 arg1, f32 arg2, Vec3f *arg3) {
             var_f2 *= D_80129FC8.unk44 + (var_v0 * var_f16);
         }
 
-        if (D_80129FC8.unk28 != 0) {
+        if (D_80129FC8.unk28 != FALSE) {
             spA0 *= 0.5f;
             var_f12 *= 0.5f;
             var_f2 *= 0.5f;
@@ -1078,11 +1063,14 @@ f32 func_800BB2F4(s32 arg0, f32 arg1, f32 arg2, Vec3f *arg3) {
 
         spA4 = 0.0f;
         arg3X = (spA0 - var_f2) * sp90;
-        arg3Z = sp90 * sp94;
-        arg3Y = (spA0 - var_f12) * sp94;
+        arg3Y = sp90 * sp94;
+        arg3Z = (spA0 - var_f12) * sp94;
     } else {
-        var_a0 =
-            (var_t0 + 1) >= D_80129FC8.unk4 ? var_a3 * D_80129FC8.unk4 : (var_t0 + 0) + (var_a3 * D_80129FC8.unk4) + 1;
+        if ((var_t0 + 1) >= D_80129FC8.unk4) {
+            var_a0 = var_a3 * D_80129FC8.unk4;
+        } else {
+            var_a0 = (var_t0 + 0) + (var_a3 * D_80129FC8.unk4) + 1;
+        }
         spA0 = (D_800E3040[D_800E3044[var_a0].s[0]] + D_800E3040[D_800E3044[var_a0].s[1]]) * D_80129FC8.magnitude;
         if (D_800E3188 > 0) {
             spA0 += func_800BEFC4(arg0, sp70 + 1, sp6C);
@@ -1121,7 +1109,7 @@ f32 func_800BB2F4(s32 arg0, f32 arg1, f32 arg2, Vec3f *arg3) {
             var_f2 *= D_80129FC8.unk44 + (var_v0 * var_f16);
         }
 
-        if (D_80129FC8.unk28 != 0) {
+        if (D_80129FC8.unk28 != FALSE) {
             spA0 *= 0.5f;
             var_f12 *= 0.5f;
             var_f2 *= 0.5f;
@@ -1129,34 +1117,34 @@ f32 func_800BB2F4(s32 arg0, f32 arg1, f32 arg2, Vec3f *arg3) {
 
         spA4 = sp94;
         arg3X = sp90 * (var_f12 - var_f2);
-        arg3Z = sp90 * sp94;
-        arg3Y = sp94 * (spA0 - var_f2);
+        arg3Y = sp90 * sp94;
+        arg3Z = sp94 * (spA0 - var_f2);
     }
 
-    var_f16 = sqrtf((arg3X * arg3X) + (arg3Z * arg3Z) + (arg3Y * arg3Y));
-    if (var_f16 != 0.0 && arg3Z != 0.0) {
+    var_f16 = sqrtf((arg3X * arg3X) + (arg3Y * arg3Y) + (arg3Z * arg3Z));
+    if (var_f16 != 0.0 && arg3Y != 0.0) {
         arg3X /= var_f16;
-        arg3Z /= var_f16;
         arg3Y /= var_f16;
-        sp78 -= (((arg3X * arg1) + (arg3Y * arg2)) - ((spA4 * arg3X) + (spA0 * arg3Z))) / arg3Z;
+        arg3Z /= var_f16;
+        sp78 -= (((arg3X * arg1) + (arg3Z * arg2)) - ((spA4 * arg3X) + (spA0 * arg3Y))) / arg3Y;
     }
 
     if (arg3 != NULL) {
         arg3->x = arg3X;
-        arg3->y = arg3Z;
-        arg3->z = arg3Y;
+        arg3->y = arg3Y;
+        arg3->z = arg3Z;
     }
 
     return sp78;
 }
 
 void func_800BBDDC(LevelModel *level, LevelHeader *header) {
-    func_800BBE08(level, (unk800BBE08_arg1 *) header);
+    func_800BBE08(level, header);
     func_800BBF78(level);
 }
 
-// TODO: arg1 should be a LevelHeader
-void func_800BBE08(LevelModel *level, unk800BBE08_arg1 *arg1) {
+// determines current bounding box, batch and texture
+void func_800BBE08(LevelModel *level, LevelHeader *header) {
     s16 numSegments;
     s32 j;
     TriangleBatchInfo *curBatch;
@@ -1192,7 +1180,7 @@ void func_800BBE08(LevelModel *level, unk800BBE08_arg1 *arg1) {
     gWaveTexture = level->textures[curBatch->textureIndex].texture;
     temp_t6 = (curBatch->flags & (BATCH_FLAGS_UNK40000000 | BATCH_FLAGS_UNK20000000 | BATCH_FLAGS_UNK10000000)) >> 28;
     if (temp_t6 > 0) {
-        D_800E3180 = (LevelHeader_70 *) arg1->unk70[temp_t6];
+        D_800E3180 = header->unk70[temp_t6];
     } else {
         D_800E3180 = 0;
     }
@@ -1214,7 +1202,7 @@ void func_800BBF78(LevelModel *model) {
     levelSegments = model->segments;
     levelSegmentBoundingBoxes = model->segmentsBoundingBoxes;
     sp44 = D_80129FC8.unk0;
-    if (D_80129FC8.unk28 != 0) {
+    if (D_80129FC8.unk28 != FALSE) {
         sp44 = sp44 * 2;
     }
     D_8012A0C0 = levelSegmentBoundingBoxes->x1;
@@ -1266,9 +1254,9 @@ void func_800BBF78(LevelModel *model) {
     );
     // clang-format on
 
-    D_800E3190 = (u32) D_800E30D8 + model->numberOfSegments * sizeof(LevelModel_Alternate);
-    D_800E3194 = (u32) D_800E3190 + 0x800;
-    D_800E3184 = (u32) D_800E3194 + 0x80;
+    D_800E3190 = (unk800E3190 *) ((u32) D_800E30D8 + model->numberOfSegments * sizeof(LevelModel_Alternate));
+    D_800E3194 = (Object **) (D_800E3190 + sizeof(unk800E3190 *) * 8);
+    D_800E3184 = (unk800E3184 *) (D_800E3194 + sizeof(Object *) * 8);
 
     for (i = 0; i < (D_800E318C * 8); i++) {
         D_800E3184->unk0[i] = 0xFF;
@@ -1499,7 +1487,7 @@ s32 func_800BDC80(s32 arg0, unkArg1 *arg1, unkArg2 *arg2, f32 shadowXNegPosition
     spCC = D_8012A0B8;
     spC8 = D_8012A0BC;
     var_f24 = (1.0f - D_80129FC8.unk44) / 127.0f;
-    if (D_80129FC8.unk28 != 0) {
+    if (D_80129FC8.unk28 != FALSE) {
         sp36C = D_80129FC8.unk0 * 2;
         spCC *= 0.5;
         spC8 *= 0.5;
@@ -1771,6 +1759,7 @@ f32 log_wave_height(Object_Log *log, s32 updateRate) {
     return y;
 }
 
+// height related calculation?
 f32 func_800BEFC4(s32 arg0, s32 arg1, s32 arg2) {
     f32 temp_f0;
     f32 temp_f12;
@@ -1794,18 +1783,19 @@ f32 func_800BEFC4(s32 arg0, s32 arg1, s32 arg2) {
     if (D_800E3188 <= 0) {
         return var_f28;
     }
-    var_f0 = D_8012A0B8;
+
     var_v1 = D_80129FC8.unk0;
+    var_f0 = D_8012A0B8;
     var_f2 = D_8012A0BC;
-    if (D_80129FC8.unk28 != 0) {
-        var_f0 *= 0.5f;
+    if (D_80129FC8.unk28 != FALSE) {
         var_v1 *= 2;
+        var_f0 *= 0.5f;
         var_f2 *= 0.5f;
     }
-    temp_a1 = ((&D_800E30D8[arg0])->unkA * var_v1) + arg1;
+    temp_a1 = (D_800E30D8[arg0].unkA * var_v1) + arg1;
     temp_a3 = &D_800E3184[temp_a1];
     if (temp_a3->unk0[0] != 0xFF) {
-        temp_0 = (arg2) + (var_v1 * (&D_800E30D8[arg0])->unkB);
+        temp_0 = arg2 + (var_v1 * D_800E30D8[arg0].unkB);
         temp_f30 = D_8012A0D0 + (temp_a1 * var_f0);
         temp_f24 = D_8012A0D4 + (temp_0 * var_f2);
         temp_f26 = 0;
@@ -1818,7 +1808,7 @@ f32 func_800BEFC4(s32 arg0, s32 arg1, s32 arg2) {
                 temp_f12 = (temp_f20 * temp_f20) + (temp_f22 * temp_f22);
                 if (temp_f12 < temp_s1->unk14) {
                     temp_f0 = sqrtf(temp_f12);
-                    var_s0 = (u16) temp_s1->unk1A;
+                    var_s0 = temp_s1->unk1A;
                     if (temp_s1->unk31 != 0) {
                         if (temp_f20 < temp_f26) {
                             var_s0 -= (s32) (temp_f20 * temp_s1->unk20);
@@ -1834,13 +1824,14 @@ f32 func_800BEFC4(s32 arg0, s32 arg1, s32 arg2) {
                     } else {
                         var_s0 += (s32) (temp_f0 * temp_s1->unk20);
                     }
-                    temp_f20 = coss_f((s16) (s32) ((temp_f0 * 65536.0f) / temp_s1->unk10));
+                    temp_f20 = coss_f((temp_f0 * 65536.0f) / temp_s1->unk10);
                     var_f28 += temp_s1->unk24 * sins_f(var_s0) * temp_f20;
                 }
             }
             var_s3++;
         } while (var_s3 < 8 && temp_a3->unk0[var_s3] != 0xFF);
     }
+
     return var_f28;
 }
 
@@ -1851,45 +1842,54 @@ void func_800BF3E4(Object *obj) {
     s32 m;
     unk800E3184 *temp_a1;
 
-    if (D_800E3190 != NULL) {
+    if (D_800E3190 == NULL) {
+        return;
+    }
 
-        for (i = 0, m = 0; i < D_800E3188 && m == 0; i++) {
-            if (obj == D_800E3194[i]) {
-                m = -1;
-            }
-        }
-        if (m != 0) {
-            i--;
-            for (j = 0; j < D_800E318C; j++) {
-                for (k = 0, temp_a1 = &D_800E3184[j]; k < 8 && temp_a1->unk0[k] != 0xFF; k++) {
-                    if (i == temp_a1->unk0[k]) {
-                        while (k < 7) {
-                            temp_a1->unk0[k] = temp_a1->unk0[k + 1];
-                            k++;
-                        }
-                        temp_a1->unk0[k] = 0xFF;
-                        k++;
-                    }
-                }
-            }
-            D_800E3194[j] = NULL;
-            D_800E3188--;
+    for (i = 0, m = 0; i < D_800E3188 && m == 0; i++) {
+        if (obj == D_800E3194[i]) {
+            m = -1;
         }
     }
+
+    if (m == 0) {
+        return;
+    }
+
+    i--;
+    for (j = 0; j < D_800E318C; j++) {
+        for (k = 0, temp_a1 = &D_800E3184[j]; k < 8 && temp_a1->unk0[k] != 0xFF; k++) {
+            if (i != temp_a1->unk0[k]) {
+                continue;
+            }
+
+            while (k < 7) {
+                temp_a1->unk0[k] = temp_a1->unk0[k + 1];
+                k++;
+            }
+            temp_a1->unk0[k] = 0xFF;
+            k++;
+        }
+    }
+
+    D_800E3194[j] = NULL;
+    D_800E3188--;
 }
 
 void func_800BF524(Object *obj) {
     LevelObjectEntry800BF524 *temp_v0;
     s32 var_v1;
 
-    temp_v0 = (LevelObjectEntry800BF524 *) obj->segment.level_entry;
+    temp_v0 = &obj->segment.level_entry->unk800BF524;
     var_v1 = 0;
     if (temp_v0->unk10 != 0) {
         var_v1 = 1;
     }
+
     if (temp_v0->unk11 != 0) {
         var_v1 |= 2;
     }
+
     func_800BF634(obj, obj->segment.trans.x_position, obj->segment.trans.z_position, (f32) temp_v0->unkA,
                   temp_v0->unk9 << 8, (f32) temp_v0->unk8 / 16.0, (f32) temp_v0->unkE, (f32) temp_v0->unkC / 16.0,
                   var_v1);
@@ -1914,38 +1914,45 @@ unk800E3190 *func_800BF634(Object *obj, f32 xPos, f32 zPos, f32 arg3, s32 arg4,
                 var_a0 = -1;
             }
         }
+
         i--;
         if (var_a0 != 0) {
             D_800E3194[i] = obj;
             D_800E3188++;
             var_f0 = D_8012A0B8;
-            if (D_80129FC8.unk28 != 0) {
+            if (D_80129FC8.unk28 != FALSE) {
                 var_f0 /= 2.0f;
             }
+
             var_a0_2 = (((xPos - arg3) - D_8012A0D0) / var_f0);
             if (var_a0_2 >= D_800E318C) {
-                return NULL;
+                return result;
             }
+
             var_a2_2 = (((xPos + arg3) - D_8012A0D0) / var_f0);
             if (var_a2_2 < 0) {
-                return NULL;
+                return result;
             }
+
             if (var_a0_2 < 0) {
                 var_a0_2 = 0;
             }
+
             if (var_a2_2 >= D_800E318C) {
                 var_a2_2 = D_800E318C - 1;
             }
 
             for (j = var_a0_2; j <= var_a2_2; j++) {
                 temp = &D_800E3184[j];
-                if (temp->unk0[7] == 0xFF) {
-                    k = 0;
-                    while (temp->unk0[k] != 0xFF) {
-                        k++;
-                    }
-                    temp->unk0[k] = i;
+                if (temp->unk0[7] != 0xFF) {
+                    continue;
                 }
+
+                k = 0;
+                while (temp->unk0[k] != 0xFF) {
+                    k++;
+                }
+                temp->unk0[k] = i;
             }
             result = &D_800E3190[i];
             result->unk0 = zPos - arg3;
@@ -1969,6 +1976,7 @@ unk800E3190 *func_800BF634(Object *obj, f32 xPos, f32 zPos, f32 arg3, s32 arg4,
             result->unk2C = arg6;
         }
     }
+
     return result;
 }
 
@@ -1984,87 +1992,97 @@ UNUSED void func_800BF9F8(unk800BF9F8 *arg0, f32 arg1, f32 arg2) {
     s32 temp_v1;
     u8 *var_a2_2;
 
-    if (arg0 != NULL) {
-        var_f0 = D_8012A0B8;
-        iteration = 0;
-        if (D_80129FC8.unk28 != 0) {
-            var_f0 *= 0.5f;
+    if (arg0 == NULL) {
+        return;
+    }
+
+    var_f0 = D_8012A0B8;
+    iteration = 0;
+    if (D_80129FC8.unk28 != FALSE) {
+        var_f0 *= 0.5f;
+    }
+    temp_v1 = arg0->unk18;
+    while (iteration != 2) {
+        var_a1 = TRUE;
+        var_a2 = ((arg0->unk8 - arg0->unk10) - D_8012A0D0) / var_f0;
+        if (var_a2 >= D_800E318C) {
+            var_a1 = FALSE;
+        } else if (var_a2 < 0) {
+            var_a2 = 0;
         }
-        temp_v1 = arg0->unk18;
-        while (iteration != 2) {
-            var_a1 = TRUE;
-            var_a2 = (((arg0->unk8 - arg0->unk10) - D_8012A0D0) / var_f0);
-            if (var_a2 >= D_800E318C) {
+
+        if (var_a1) {
+            sp1C = ((arg0->unk8 + arg0->unk10) - D_8012A0D0) / var_f0;
+            if (sp1C < 0) {
                 var_a1 = FALSE;
-            } else if (var_a2 < 0) {
-                var_a2 = 0;
+            } else if (sp1C >= D_800E318C) {
+                sp1C = D_800E318C - 1;
             }
-            if (var_a1) {
-                sp1C = (((arg0->unk8 + arg0->unk10) - D_8012A0D0) / var_f0);
-                if (sp1C < 0) {
-                    var_a1 = FALSE;
-                } else if (sp1C >= D_800E318C) {
-                    sp1C = D_800E318C - 1;
-                }
-            }
-            if (var_a1) {
-                for (i = var_a2; i <= sp1C; i++) {
-                    var_a2_2 = &D_800E3184[i].unk0[0];
-                    j = 0;
-                    if (iteration != 0) {
-                        if (var_a2_2[7] == 0xFF) {
-                            while (var_a2_2[0] != 0xFF) {
-                                var_a2_2++;
-                            }
-                            var_a2_2[0] = temp_v1;
+        }
+
+        if (var_a1) {
+            for (i = var_a2; i <= sp1C; i++) {
+                var_a2_2 = &D_800E3184[i].unk0[0];
+                j = 0;
+                if (iteration != 0) {
+                    if (var_a2_2[7] == 0xFF) {
+                        while (var_a2_2[0] != 0xFF) {
+                            var_a2_2++;
                         }
-                    } else {
-                        while (j < 8) {
-                            if (temp_v1 == var_a2_2[j]) {
-                                while (j < 7) {
-                                    var_a2_2[j] = var_a2_2[j + 1];
-                                    j++;
-                                }
-                                var_a2_2[j] = 0xFF;
+                        var_a2_2[0] = temp_v1;
+                    }
+                } else {
+                    while (j < 8) {
+                        if (temp_v1 == var_a2_2[j]) {
+                            while (j < 7) {
+                                var_a2_2[j] = var_a2_2[j + 1];
                                 j++;
                             }
+                            var_a2_2[j] = 0xFF;
                             j++;
                         }
+                        j++;
                     }
                 }
             }
-            if (iteration == 0) {
-                arg0->unk8 += arg1;
-                arg0->unkC += arg2;
-                arg0->unk0 += arg2;
-                arg0->unk4 += arg2;
-            }
-            iteration++;
         }
+
+        if (iteration == 0) {
+            arg0->unk8 += arg1;
+            arg0->unkC += arg2;
+            arg0->unk0 += arg2;
+            arg0->unk4 += arg2;
+        }
+        iteration++;
     }
 }
 
 UNUSED void func_800BFC54(unk800BFC54_arg0 *arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4) {
-    if (arg0 != NULL) {
-        arg0->unk10 = (arg0->unk10 + arg1);
-        if (arg0->unk10 < 1.0) {
-            arg0->unk10 = 1.0f;
-        }
-        arg0->unk0 = (arg0->unkC - arg0->unk10);
-        arg0->unk4 = (arg0->unkC + arg0->unk10);
-        arg0->unk28 += arg2;
-        if (osTvType == OS_TV_TYPE_PAL) {
-            arg0->unk1C = arg0->unk28 * 20971.52; //(f64) (0x80000 / 25.0);
-        } else {
-            arg0->unk1C = arg0->unk28 * 17476.27; //(f64) ((0x80000 / 1.2) / 25.0);
-        }
-        arg0->unk2C = (arg0->unk2C + arg3);
-        if (arg0->unk2C < 1.0) {
-            arg0->unk2C = 1.0f;
-        }
-        arg0->unk20 = (65536.0f / arg0->unk2C); // 0x10000
-        arg0->unk24 = (arg0->unk24 + arg4);
+    if (arg0 == NULL) {
+        return;
     }
+
+    arg0->unk10 = (arg0->unk10 + arg1);
+    if (arg0->unk10 < 1.0) {
+        arg0->unk10 = 1.0f;
+    }
+
+    arg0->unk0 = (arg0->unkC - arg0->unk10);
+    arg0->unk4 = (arg0->unkC + arg0->unk10);
+    arg0->unk28 += arg2;
+    if (osTvType == OS_TV_TYPE_PAL) {
+        arg0->unk1C = arg0->unk28 * 20971.52; //(f64) (0x80000 / 25.0);
+    } else {
+        arg0->unk1C = arg0->unk28 * 17476.27; //(f64) ((0x80000 / 1.2) / 25.0);
+    }
+
+    arg0->unk2C = arg0->unk2C + arg3;
+    if (arg0->unk2C < 1.0) {
+        arg0->unk2C = 1.0f;
+    }
+
+    arg0->unk20 = 65536.0f / arg0->unk2C; // 0x10000
+    arg0->unk24 = arg0->unk24 + arg4;
 }
 
 void func_800BFE98(s32 arg0) {
@@ -2072,7 +2090,7 @@ void func_800BFE98(s32 arg0) {
 
     for (i = 0; i < 32; i++) {
         if (D_800E3194[i] != NULL) {
-            D_800E3190[i].unk1A += ((0, D_800E3190[i].unk1C * arg0)) >> 4;
+            D_800E3190[i].unk1A += (0, D_800E3190[i].unk1C * arg0) >> 4;
         }
     }
 }
@@ -2093,30 +2111,37 @@ void obj_loop_wavepower(Object *obj) {
     f32 diffX;
     f32 distance;
 
-    if (obj != gWaveGeneratorObj) {
-        racers = get_racer_objects(&numRacers);
-        if (numRacers > 0) {
-            racerObj = NULL;
-            for (i = 0; i < numRacers && racerObj == NULL; i++) {
-                racer = (Object_Racer *) racers[i]->unk64;
-                if (racer->playerIndex == PLAYER_ONE) {
-                    racerObj = racers[i];
-                }
-            }
-            if (racerObj != NULL) {
-                entry = (LevelObjectEntry_WavePower *) obj->segment.level_entry;
-                distance = entry->radius;
-                distance *= distance;
-                diffX = racerObj->segment.trans.x_position - obj->segment.trans.x_position;
-                diffY = racerObj->segment.trans.y_position - obj->segment.trans.y_position;
-                diffZ = racerObj->segment.trans.z_position - obj->segment.trans.z_position;
-                if ((diffX * diffX) + (diffY * diffY) + (diffZ * diffZ) < distance) {
-                    gWavePowerBase = entry->power / 256.0f;
-                    gWaveMagnitude = (gWavePowerBase - D_80129FC8.magnitude) / (f32) entry->divisor;
-                    gWavePowerDivisor = entry->divisor;
-                    gWaveGeneratorObj = obj;
-                }
-            }
+    if (obj == gWaveGeneratorObj) {
+        return;
+    }
+
+    racers = get_racer_objects(&numRacers);
+    if (numRacers <= 0) {
+        return;
+    }
+
+    racerObj = NULL;
+    for (i = 0; i < numRacers && racerObj == NULL; i++) {
+        racer = &racers[i]->unk64->racer;
+        if (racer->playerIndex == PLAYER_ONE) {
+            racerObj = racers[i];
         }
     }
+
+    if (racerObj == NULL) {
+        return;
+    }
+
+    entry = &obj->segment.level_entry->wavePower;
+    distance = entry->radius;
+    distance *= distance;
+    diffX = racerObj->segment.trans.x_position - obj->segment.trans.x_position;
+    diffY = racerObj->segment.trans.y_position - obj->segment.trans.y_position;
+    diffZ = racerObj->segment.trans.z_position - obj->segment.trans.z_position;
+    if ((diffX * diffX) + (diffY * diffY) + (diffZ * diffZ) < distance) {
+        gWavePowerBase = entry->power / 256.0f;
+        gWaveMagnitude = (gWavePowerBase - D_80129FC8.magnitude) / (f32) entry->divisor;
+        gWavePowerDivisor = entry->divisor;
+        gWaveGeneratorObj = obj;
+    }
 }
diff --git a/src/waves.h b/src/waves.h
index ddc26f06..d1dfad01 100644
--- a/src/waves.h
+++ b/src/waves.h
@@ -4,22 +4,26 @@
 #include "types.h"
 #include "structs.h"
 
+/* Size: 4 bytes */
 typedef struct {
     u8 unk0[4];
 } LevelModelSubArray;
+
+/* Size: 0x1C bytes */
 typedef struct {
     LevelModelSegment *unk00;
-    s16 unk4;
-    s16 unk6; // used as playerIndex
-    s16 unk8;
-    u8 unkA;
-    u8 unkB;
-    u32 unkC;
+    s16 unk4; // something with x
+    s16 unk6; // something with y AND used as playerIndex
+    s16 unk8; // something with z
+    u8 unkA; // some sort of x ratio
+    u8 unkB; // some sort of z ratio / index of D_8012A0E8
+    u32 unkC; // indexes D_800E30D4
     s16 unk10;
     s16 unk12;
     LevelModelSubArray unk14[2];
 } LevelModel_Alternate;
 
+/* Size: 0x40 bytes */
 typedef struct unk800E3190 {
     f32 unk0;
     f32 unk4;
@@ -44,26 +48,26 @@ typedef struct unk800E3184 {
 } unk800E3184;
 
 typedef struct unk80129FC8 {
-    s32 unk0;
-    s32 unk4;
-    s32 unk8;
-    f32 unkC;
-    s32 unk10;
-    s32 unk14;
-    f32 unk18;
-    s32 unk1C;
-    s32 unk20;
-    s32 unk24;
-    s32 unk28;
-    s32 unk2C;
-    s32 unk30;
-    s32 unk34;
-    s32 unk38;
-    s32 unk3C;
+    s32 unk0; // count or index?
+    s32 unk4; // compared to and substracted
+    s32 unk8; // used to populate D_800E3040
+    f32 unkC; // used to populate D_800E3040
+    s32 unk10; // used to populate D_800E3040
+    s32 unk14; // used to populate D_800E3040
+    f32 unk18; // used to populate D_800E3040
+    s32 unk1C; // used to populate D_800E3040
+    s32 unk20; // count of elements in D_800E3040
+    s32 unk24; // possible values: 3 or 5, controls what's set for D_800E30E0 and D_800E30E4
+    s32 unk28; // some sort of flag
+    s32 textureId;
+    s32 unk30; // multiplier for texture width
+    s32 unk34; // multiplier for texture height
+    s32 unk38; // used in u of uv calculation for wave triangles
+    s32 unk3C; // used in v of uv calculation for wave triangles
     f32 magnitude; // Global wave strength
-    f32 unk44;
-    f32 unk48;
-    s32 unk4C;
+    f32 unk44; // something related to height / scale
+    f32 unk48; // used in vertex RGBA calculation
+    s32 darkVertexColours;
 } unk80129FC8;
 
 typedef struct unk800BBE08_arg1 {
@@ -122,7 +126,7 @@ s32 func_800B9228(LevelModelSegment *arg0);
 void func_800BBDDC(LevelModel *level, LevelHeader *header);
 void func_800BFE98(s32 arg0);
 void func_800B8134(LevelHeader *header);
-void func_800BBE08(LevelModel *level, unk800BBE08_arg1 *arg1);
+void func_800BBE08(LevelModel *level, LevelHeader *arg1);
 void obj_loop_wavepower(Object *obj);
 void func_800BFC54(unk800BFC54_arg0 *arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4);
 void func_800BF3E4(Object *obj);
diff --git a/ver/symbols/symbol_addrs.jpn.v79.txt b/ver/symbols/symbol_addrs.jpn.v79.txt
index 8d795a51..2b54f6c0 100644
--- a/ver/symbols/symbol_addrs.jpn.v79.txt
+++ b/ver/symbols/symbol_addrs.jpn.v79.txt
@@ -2868,11 +2868,11 @@ D_800E3040 = 0x800E4B30;
 D_800E3044 = 0x800E4B34;
 D_800E3048 = 0x800E4B38;
 D_800E304C = 0x800E4B3C;
-D_800E3070 = 0x800E4B60;
+gWaveVertices = 0x800E4B60;
 D_800E3078 = 0x800E4B68;
-D_800E3080 = 0x800E4B70;
+gWaveTriangles = 0x800E4B70;
 D_800E3090 = 0x800E4B80;
-D_800E30D0 = 0x800E4BC0;
+gWaveTextureHeader = 0x800E4BC0;
 D_800E30D4 = 0x800E4BC4;
 D_800E30D8 = 0x800E4BC8;
 D_800E30DC = 0x800E4BCC;
@@ -4482,7 +4482,7 @@ D_80129BB0 = 0x8012B660; // size:0x400
 gObjectStackTrace = 0x8012BA60; // size:0x10
 
 // waves .bss
-D_80129FC0 = 0x8012BA70;
+gWaveDL = 0x8012BA70;
 D_80129FC4 = 0x8012BA74;
 D_80129FC8 = 0x8012BA78; // size:0x50
 D_8012A018 = 0x8012BAC8;
diff --git a/ver/symbols/symbol_addrs.pal.v77.txt b/ver/symbols/symbol_addrs.pal.v77.txt
index 0b5ec937..517489b4 100644
--- a/ver/symbols/symbol_addrs.pal.v77.txt
+++ b/ver/symbols/symbol_addrs.pal.v77.txt
@@ -2702,11 +2702,11 @@ D_800E3040 = 0x800E30D0;
 D_800E3044 = 0x800E30D4;
 D_800E3048 = 0x800E30D8;
 D_800E304C = 0x800E30DC;
-D_800E3070 = 0x800E3100;
+gWaveVertices = 0x800E3100;
 D_800E3078 = 0x800E3108;
-D_800E3080 = 0x800E3110;
+gWaveTriangles = 0x800E3110;
 D_800E3090 = 0x800E3120;
-D_800E30D0 = 0x800E3160;
+gWaveTextureHeader = 0x800E3160;
 D_800E30D4 = 0x800E3164;
 D_800E30D8 = 0x800E3168;
 D_800E30DC = 0x800E316C;
@@ -4166,7 +4166,7 @@ D_801299B0 = 0x80129A40; // size:0x100
 D_80129AB0 = 0x80129B40; // size:0x100
 D_80129BB0 = 0x80129C40; // size:0x400
 gObjectStackTrace = 0x8012A040; // size:0x10
-D_80129FC0 = 0x8012A050;
+gWaveDL = 0x8012A050;
 D_80129FC4 = 0x8012A054;
 D_80129FC8 = 0x8012A058; // size:0x50
 D_8012A018 = 0x8012A0A8;
diff --git a/ver/symbols/symbol_addrs.pal.v80.txt b/ver/symbols/symbol_addrs.pal.v80.txt
index e2f0bbe6..5c0d4b96 100644
--- a/ver/symbols/symbol_addrs.pal.v80.txt
+++ b/ver/symbols/symbol_addrs.pal.v80.txt
@@ -2631,11 +2631,11 @@ D_800E3040 = 0x800E3660;
 D_800E3044 = 0x800E3664;
 D_800E3048 = 0x800E3668;
 D_800E304C = 0x800E366C;
-D_800E3070 = 0x800E3690;
+gWaveVertices = 0x800E3690;
 D_800E3078 = 0x800E3698;
-D_800E3080 = 0x800E36A0;
+gWaveTriangles = 0x800E36A0;
 D_800E3090 = 0x800E36B0;
-D_800E30D0 = 0x800E36F0;
+gWaveTextureHeader = 0x800E36F0;
 D_800E30D4 = 0x800E36F4;
 D_800E30D8 = 0x800E36F8;
 D_800E30DC = 0x800E36FC;
@@ -4101,7 +4101,7 @@ D_801299B0 = 0x8012A000; // size:0x100
 D_80129AB0 = 0x8012A100; // size:0x100
 D_80129BB0 = 0x8012A200; // size:0x400
 gObjectStackTrace = 0x8012A600; // size:0x10
-D_80129FC0 = 0x8012A610;
+gWaveDL = 0x8012A610;
 D_80129FC4 = 0x8012A614;
 D_80129FC8 = 0x8012A618; // size:0x50
 D_8012A018 = 0x8012A668;
diff --git a/ver/symbols/symbol_addrs.us.v77.txt b/ver/symbols/symbol_addrs.us.v77.txt
index a79a118a..a1bd5d49 100644
--- a/ver/symbols/symbol_addrs.us.v77.txt
+++ b/ver/symbols/symbol_addrs.us.v77.txt
@@ -2859,11 +2859,11 @@ D_800E3040 = 0x800E3040;
 D_800E3044 = 0x800E3044;
 D_800E3048 = 0x800E3048;
 D_800E304C = 0x800E304C;
-D_800E3070 = 0x800E3070;
+gWaveVertices = 0x800E3070;
 D_800E3078 = 0x800E3078;
-D_800E3080 = 0x800E3080;
+gWaveTriangles = 0x800E3080;
 D_800E3090 = 0x800E3090;
-D_800E30D0 = 0x800E30D0;
+gWaveTextureHeader = 0x800E30D0;
 D_800E30D4 = 0x800E30D4;
 D_800E30D8 = 0x800E30D8;
 D_800E30DC = 0x800E30DC;
@@ -4611,7 +4611,7 @@ D_80129BB0 = 0x80129BB0; // size:0x400
 gObjectStackTrace = 0x80129FB0; // size:0x10
 
 // waves .bss
-D_80129FC0 = 0x80129FC0;
+gWaveDL = 0x80129FC0;
 D_80129FC4 = 0x80129FC4;
 D_80129FC8 = 0x80129FC8; // size:0x50
 D_8012A018 = 0x8012A018;
diff --git a/ver/symbols/symbol_addrs.us.v80.txt b/ver/symbols/symbol_addrs.us.v80.txt
index 34ba7c82..a5782c60 100644
--- a/ver/symbols/symbol_addrs.us.v80.txt
+++ b/ver/symbols/symbol_addrs.us.v80.txt
@@ -2628,11 +2628,11 @@ D_800E3040 = 0x800E35D0;
 D_800E3044 = 0x800E35D4;
 D_800E3048 = 0x800E35D8;
 D_800E304C = 0x800E35DC;
-D_800E3070 = 0x800E3600;
+gWaveVertices = 0x800E3600;
 D_800E3078 = 0x800E3608;
-D_800E3080 = 0x800E3610;
+gWaveTriangles = 0x800E3610;
 D_800E3090 = 0x800E3620;
-D_800E30D0 = 0x800E3660;
+gWaveTextureHeader = 0x800E3660;
 D_800E30D4 = 0x800E3664;
 D_800E30D8 = 0x800E3668;
 D_800E30DC = 0x800E366C;
@@ -4096,7 +4096,7 @@ D_801299B0 = 0x80129F70; // size:0x100
 D_80129AB0 = 0x8012A070; // size:0x100
 D_80129BB0 = 0x8012A170; // size:0x400
 gObjectStackTrace = 0x8012A570; // size:0x10
-D_80129FC0 = 0x8012A580;
+gWaveDL = 0x8012A580;
 D_80129FC4 = 0x8012A584;
 D_80129FC8 = 0x8012A588; // size:0x50
 D_8012A018 = 0x8012A5D8;