diff --git a/src/openrct2-ui/windows/Footpath.cpp b/src/openrct2-ui/windows/Footpath.cpp
index 285af18c38..6fd2013c45 100644
--- a/src/openrct2-ui/windows/Footpath.cpp
+++ b/src/openrct2-ui/windows/Footpath.cpp
@@ -795,10 +795,10 @@ static void window_footpath_set_provisional_path_at_point(sint32 x, sint32 y)
     gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
 
     sint32 interactionType;
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
     LocationXY16 mapCoord = {0};
     get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_FOOTPATH & VIEWPORT_INTERACTION_MASK_TERRAIN,
-                                 &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, nullptr);
+                                 &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, nullptr);
     x = mapCoord.x;
     y = mapCoord.y;
 
@@ -814,7 +814,7 @@ static void window_footpath_set_provisional_path_at_point(sint32 x, sint32 y)
             (gFootpathProvisionalFlags & PROVISIONAL_PATH_FLAG_1) &&
             gFootpathProvisionalPosition.x == x &&
             gFootpathProvisionalPosition.y == y &&
-            gFootpathProvisionalPosition.z == mapElement->base_height
+            gFootpathProvisionalPosition.z == tileElement->base_height
             )
         {
             return;
@@ -831,14 +831,14 @@ static void window_footpath_set_provisional_path_at_point(sint32 x, sint32 y)
         footpath_provisional_update();
 
         // Set provisional path
-        sint32 slope = default_path_slope[mapElement->properties.surface.slope & 0x1F];
+        sint32 slope = default_path_slope[tileElement->properties.surface.slope & 0x1F];
         if (interactionType == VIEWPORT_INTERACTION_ITEM_FOOTPATH)
         {
-            slope = mapElement->properties.surface.slope & 7;
+            slope = tileElement->properties.surface.slope & 7;
         }
         sint32 pathType = (gFootpathSelectedType << 7) + (gFootpathSelectedId & 0xFF);
 
-        _window_footpath_cost = footpath_provisional_set(pathType, x, y, mapElement->base_height, slope);
+        _window_footpath_cost = footpath_provisional_set(pathType, x, y, tileElement->base_height, slope);
         window_invalidate_by_class(WC_FOOTPATH);
     }
 }
@@ -850,13 +850,13 @@ static void window_footpath_set_provisional_path_at_point(sint32 x, sint32 y)
 static void window_footpath_set_selection_start_bridge_at_point(sint32 screenX, sint32 screenY)
 {
     sint32 x, y, direction;
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
 
     map_invalidate_selection_rect();
     gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;
     gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
 
-    footpath_bridge_get_info_from_pos(screenX, screenY, &x, &y, &direction, &mapElement);
+    footpath_bridge_get_info_from_pos(screenX, screenY, &x, &y, &direction, &tileElement);
     if (x == LOCATION_NULL)
     {
         return;
@@ -874,11 +874,11 @@ static void window_footpath_set_selection_start_bridge_at_point(sint32 screenX,
     gMapSelectArrowPosition.x = x;
     gMapSelectArrowPosition.y = y;
 
-    sint32 z = mapElement->base_height;
+    sint32 z = tileElement->base_height;
 
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE)
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
     {
-        uint8 slope = mapElement->properties.surface.slope;
+        uint8 slope = tileElement->properties.surface.slope;
         if (slope & 0xf)
         {
             z += 2;
@@ -899,7 +899,7 @@ static void window_footpath_set_selection_start_bridge_at_point(sint32 screenX,
 static void window_footpath_place_path_at_point(sint32 x, sint32 y)
 {
     sint32 interactionType, presentType, selectedType, z, cost;
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
 
     if (_footpathErrorOccured)
     {
@@ -910,7 +910,7 @@ static void window_footpath_place_path_at_point(sint32 x, sint32 y)
 
     LocationXY16 mapCoord = {0};
     get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_FOOTPATH & VIEWPORT_INTERACTION_MASK_TERRAIN,
-                                 &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, nullptr);
+                                 &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, nullptr);
     x = mapCoord.x;
     y = mapCoord.y;
 
@@ -920,12 +920,12 @@ static void window_footpath_place_path_at_point(sint32 x, sint32 y)
     }
 
     // Set path
-    presentType  = default_path_slope[mapElement->properties.path.type & 0x1F];
+    presentType  = default_path_slope[tileElement->properties.path.type & 0x1F];
     if (interactionType == VIEWPORT_INTERACTION_ITEM_FOOTPATH)
     {
-        presentType = mapElement->properties.path.type & 7;
+        presentType = tileElement->properties.path.type & 7;
     }
-    z            = mapElement->base_height;
+    z            = tileElement->base_height;
     selectedType = (gFootpathSelectedType << 7) + (gFootpathSelectedId & 0xFF);
 
     // Try and place path
@@ -952,20 +952,20 @@ static void window_footpath_place_path_at_point(sint32 x, sint32 y)
 static void window_footpath_start_bridge_at_point(sint32 screenX, sint32 screenY)
 {
     sint32 x, y, z, direction;
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
 
-    footpath_bridge_get_info_from_pos(screenX, screenY, &x, &y, &direction, &mapElement);
+    footpath_bridge_get_info_from_pos(screenX, screenY, &x, &y, &direction, &tileElement);
     if (x == LOCATION_NULL)
     {
         return;
     }
 
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE)
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
     {
         // If we start the path on a slope, the arrow is slightly raised, so we
         // expect the path to be slightly raised as well.
-        uint8 slope = mapElement->properties.surface.slope;
-        z = mapElement->base_height;
+        uint8 slope = tileElement->properties.surface.slope;
+        z = tileElement->base_height;
         if (slope & 0x10)
         {
             // Steep diagonal slope
@@ -979,12 +979,12 @@ static void window_footpath_start_bridge_at_point(sint32 screenX, sint32 screenY
     }
     else
     {
-        z = mapElement->base_height;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
+        z = tileElement->base_height;
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
         {
-            if (mapElement->properties.path.type & 4)
+            if (tileElement->properties.path.type & 4)
             {
-                if (direction == (mapElement->properties.path.type & 3))
+                if (direction == (tileElement->properties.path.type & 3))
                 {
                     z += 2;
                 }
@@ -1064,12 +1064,12 @@ static void window_footpath_construct()
  *
  *  rct2: 0x006A78EF
  */
-static void footpath_remove_tile_element(rct_tile_element * mapElement)
+static void footpath_remove_tile_element(rct_tile_element * tileElement)
 {
     sint32 x, y, z;
 
-    z = mapElement->base_height;
-    sint32 pathType = mapElement->properties.path.type;
+    z = tileElement->base_height;
+    sint32 pathType = tileElement->properties.path.type;
     if (pathType & 4)
     {
         pathType &= 3;
@@ -1082,16 +1082,16 @@ static void footpath_remove_tile_element(rct_tile_element * mapElement)
 
     // Find a connected edge
     sint32 edge = gFootpathConstructDirection ^2;
-    if (!(mapElement->properties.path.edges & (1 << edge)))
+    if (!(tileElement->properties.path.edges & (1 << edge)))
     {
         edge = (edge + 1) & 3;
-        if (!(mapElement->properties.path.edges & (1 << edge)))
+        if (!(tileElement->properties.path.edges & (1 << edge)))
         {
             edge = (edge + 2) & 3;
-            if (!(mapElement->properties.path.edges & (1 << edge)))
+            if (!(tileElement->properties.path.edges & (1 << edge)))
             {
                 edge = (edge - 1) & 3;
-                if (!(mapElement->properties.path.edges & (1 << edge)))
+                if (!(tileElement->properties.path.edges & (1 << edge)))
                 {
                     edge ^= 2;
                 }
@@ -1104,7 +1104,7 @@ static void footpath_remove_tile_element(rct_tile_element * mapElement)
     footpath_remove(
         gFootpathConstructFromPosition.x,
         gFootpathConstructFromPosition.y,
-        mapElement->base_height,
+        tileElement->base_height,
         1
     );
 
@@ -1125,7 +1125,7 @@ static void footpath_remove_tile_element(rct_tile_element * mapElement)
  */
 static rct_tile_element * footpath_get_tile_element_to_remove()
 {
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
     sint32 x, y, z, zLow;
 
     x = gFootpathConstructFromPosition.x / 32;
@@ -1138,38 +1138,38 @@ static rct_tile_element * footpath_get_tile_element_to_remove()
     z    = (gFootpathConstructFromPosition.z >> 3) & 0xFF;
     zLow = z - 2;
 
-    mapElement = map_get_first_element_at(x, y);
+    tileElement = map_get_first_element_at(x, y);
     do
     {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
         {
-            if (mapElement->base_height == z)
+            if (tileElement->base_height == z)
             {
-                if (mapElement->properties.path.type & 4)
+                if (tileElement->properties.path.type & 4)
                 {
-                    if (((mapElement->properties.path.type & 3) ^ 2) != gFootpathConstructDirection)
+                    if (((tileElement->properties.path.type & 3) ^ 2) != gFootpathConstructDirection)
                     {
                         continue;
                     }
                 }
 
-                return mapElement;
+                return tileElement;
             }
-            else if (mapElement->base_height == zLow)
+            else if (tileElement->base_height == zLow)
             {
-                if (!(mapElement->properties.path.type & 4))
+                if (!(tileElement->properties.path.type & 4))
                 {
-                    if ((mapElement->properties.path.type & 3) == gFootpathConstructDirection)
+                    if ((tileElement->properties.path.type & 3) == gFootpathConstructDirection)
                     {
                         continue;
                     }
                 }
 
-                return mapElement;
+                return tileElement;
             }
         }
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     return nullptr;
 }
@@ -1180,15 +1180,15 @@ static rct_tile_element * footpath_get_tile_element_to_remove()
  */
 static void window_footpath_remove()
 {
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
 
     _window_footpath_cost = MONEY32_UNDEFINED;
     footpath_provisional_update();
 
-    mapElement = footpath_get_tile_element_to_remove();
-    if (mapElement != nullptr)
+    tileElement = footpath_get_tile_element_to_remove();
+    if (tileElement != nullptr)
     {
-        footpath_remove_tile_element(mapElement);
+        footpath_remove_tile_element(tileElement);
     }
 
     window_footpath_set_enabled_and_pressed_widgets();
diff --git a/src/openrct2-ui/windows/Guest.cpp b/src/openrct2-ui/windows/Guest.cpp
index 0a3112b91e..fb665a7ef2 100644
--- a/src/openrct2-ui/windows/Guest.cpp
+++ b/src/openrct2-ui/windows/Guest.cpp
@@ -1194,14 +1194,14 @@ void window_guest_overview_tool_down(rct_window* w, rct_widgetindex widgetIndex,
         return;
 
     sint32 dest_x, dest_y;
-    rct_tile_element* mapElement;
-    footpath_get_coordinates_from_pos(x, y + 16, &dest_x, &dest_y, nullptr, &mapElement);
+    rct_tile_element* tileElement;
+    footpath_get_coordinates_from_pos(x, y + 16, &dest_x, &dest_y, nullptr, &tileElement);
 
     if (dest_x == LOCATION_NULL)
         return;
 
     game_command_callback = game_command_callback_pickup_guest;
-    game_do_command(w->number, GAME_COMMAND_FLAG_APPLY, 2, mapElement->base_height, GAME_COMMAND_PICKUP_GUEST, dest_x, dest_y);
+    game_do_command(w->number, GAME_COMMAND_FLAG_APPLY, 2, tileElement->base_height, GAME_COMMAND_PICKUP_GUEST, dest_x, dest_y);
 }
 
 /**
diff --git a/src/openrct2-ui/windows/Map.cpp b/src/openrct2-ui/windows/Map.cpp
index 45d48ab6ed..e1510f2e0b 100644
--- a/src/openrct2-ui/windows/Map.cpp
+++ b/src/openrct2-ui/windows/Map.cpp
@@ -1213,19 +1213,19 @@ static void window_map_set_land_rights_tool_update(sint32 x, sint32 y)
  */
 static void place_park_entrance_get_map_position(sint32 x, sint32 y, sint16 *mapX, sint16 *mapY, sint16 *mapZ, sint32 *direction)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    sub_68A15E(x, y, mapX, mapY, direction, &mapElement);
+    sub_68A15E(x, y, mapX, mapY, direction, &tileElement);
     if (*mapX == LOCATION_NULL)
         return;
 
-    mapElement = map_get_surface_element_at(*mapX >> 5, *mapY >> 5);
-    *mapZ = map_get_water_height(mapElement);
+    tileElement = map_get_surface_element_at(*mapX >> 5, *mapY >> 5);
+    *mapZ = map_get_water_height(tileElement);
     if (*mapZ == 0) {
-        *mapZ = mapElement->base_height / 2;
-        if ((mapElement->properties.surface.slope & 0x0F) != 0) {
+        *mapZ = tileElement->base_height / 2;
+        if ((tileElement->properties.surface.slope & 0x0F) != 0) {
             (*mapZ)++;
-            if (mapElement->properties.surface.slope & 0x10) {
+            if (tileElement->properties.surface.slope & 0x10) {
                 (*mapZ)++;
             }
         }
@@ -1284,20 +1284,20 @@ static void window_map_place_park_entrance_tool_update(sint32 x, sint32 y)
 static void window_map_set_peep_spawn_tool_update(sint32 x, sint32 y)
 {
     sint32 mapX, mapY, mapZ, direction;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     map_invalidate_selection_rect();
     gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE;
     gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
-    footpath_bridge_get_info_from_pos(x, y, &mapX, &mapY, &direction, &mapElement);
+    footpath_bridge_get_info_from_pos(x, y, &mapX, &mapY, &direction, &tileElement);
     if ((mapX & 0xFFFF) == 0x8000)
         return;
 
-    mapZ = mapElement->base_height * 8;
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE) {
-        if ((mapElement->properties.surface.slope & 0x0F) != 0)
+    mapZ = tileElement->base_height * 8;
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE) {
+        if ((tileElement->properties.surface.slope & 0x0F) != 0)
             mapZ += 16;
-        if (mapElement->properties.surface.slope & 0x10)
+        if (tileElement->properties.surface.slope & 0x10)
             mapZ += 16;
     }
 
@@ -1347,24 +1347,24 @@ static void window_map_place_park_entrance_tool_down(sint32 x, sint32 y)
  */
 static void window_map_set_peep_spawn_tool_down(sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement, *surfaceMapElement;
+    rct_tile_element *tileElement, *surfaceTileElement;
     sint32 mapX, mapY, mapZ, direction;
 
-    footpath_get_coordinates_from_pos(x, y, &mapX, &mapY, &direction, &mapElement);
+    footpath_get_coordinates_from_pos(x, y, &mapX, &mapY, &direction, &tileElement);
     if (mapX == 0x8000)
         return;
 
-    surfaceMapElement = map_get_surface_element_at(mapX >> 5, mapY >> 5);
-    if (surfaceMapElement == nullptr) {
+    surfaceTileElement = map_get_surface_element_at(mapX >> 5, mapY >> 5);
+    if (surfaceTileElement == nullptr) {
         return;
     }
-    if (surfaceMapElement->properties.surface.ownership & 0xF0) {
+    if (surfaceTileElement->properties.surface.ownership & 0xF0) {
         return;
     }
 
     mapX = mapX + 16 + (word_981D6C[direction].x * 15);
     mapY = mapY + 16 + (word_981D6C[direction].y * 15);
-    mapZ = mapElement->base_height / 2;
+    mapZ = tileElement->base_height / 2;
 
     sint32 peepSpawnIndex = -1;
     for (sint32 i = 0; i < MAX_PEEP_SPAWNS; i++) {
@@ -1578,25 +1578,25 @@ static const uint8 RideColourKey[] = {
 
 static uint16 map_window_get_pixel_colour_peep(sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     uint16 colour;
 
-    mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-    colour = TerrainColour[tile_element_get_terrain(mapElement)];
-    if (map_get_water_height(mapElement) > 0)
+    tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+    colour = TerrainColour[tile_element_get_terrain(tileElement)];
+    if (map_get_water_height(tileElement) > 0)
         colour = WaterColour;
 
-    if (!(mapElement->properties.surface.ownership & OWNERSHIP_OWNED))
+    if (!(tileElement->properties.surface.ownership & OWNERSHIP_OWNED))
         colour = PALETTE_INDEX_10 | (colour & 0xFF00);
 
-    const sint32 maxSupportedMapElementType = (sint32)Util::CountOf(ElementTypeAddColour);
-    while (!tile_element_is_last_for_tile(mapElement++)) {
-        sint32 mapElementType = tile_element_get_type(mapElement) >> 2;
-        if (mapElementType >= maxSupportedMapElementType) {
-            mapElementType = TILE_ELEMENT_TYPE_CORRUPT >> 2;
+    const sint32 maxSupportedTileElementType = (sint32)Util::CountOf(ElementTypeAddColour);
+    while (!tile_element_is_last_for_tile(tileElement++)) {
+        sint32 tileElementType = tile_element_get_type(tileElement) >> 2;
+        if (tileElementType >= maxSupportedTileElementType) {
+            tileElementType = TILE_ELEMENT_TYPE_CORRUPT >> 2;
         }
-        colour &= ElementTypeMaskColour[mapElementType];
-        colour |= ElementTypeAddColour[mapElementType];
+        colour &= ElementTypeMaskColour[tileElementType];
+        colour |= ElementTypeAddColour[tileElementType];
     }
 
     return colour;
@@ -1604,20 +1604,20 @@ static uint16 map_window_get_pixel_colour_peep(sint32 x, sint32 y)
 
 static uint16 map_window_get_pixel_colour_ride(sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     Ride *ride;
     uint32 colour;
 
     colour = FALLBACK_COLOUR(PALETTE_INDEX_13);
-    mapElement = map_get_surface_element_at(x >> 5, y >> 5);
+    tileElement = map_get_surface_element_at(x >> 5, y >> 5);
     do {
-        switch (tile_element_get_type(mapElement)) {
+        switch (tile_element_get_type(tileElement)) {
         case TILE_ELEMENT_TYPE_SURFACE:
-            if (map_get_water_height(mapElement) > 0) {
+            if (map_get_water_height(tileElement) > 0) {
                 colour &= 0xFFFF;
                 colour |= FALLBACK_COLOUR(PALETTE_INDEX_194);
             }
-            if (!(mapElement->properties.surface.ownership & OWNERSHIP_OWNED)) {
+            if (!(tileElement->properties.surface.ownership & OWNERSHIP_OWNED)) {
                 colour &= 0xFF00FFFF;
                 colour |= PALETTE_INDEX_10 << 16;
             }
@@ -1626,15 +1626,15 @@ static uint16 map_window_get_pixel_colour_ride(sint32 x, sint32 y)
             colour = MAP_COLOUR(PALETTE_INDEX_14);
             break;
         case TILE_ELEMENT_TYPE_ENTRANCE:
-            if (mapElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE)
+            if (tileElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE)
                 break;
             // fall-through
         case TILE_ELEMENT_TYPE_TRACK:
-            ride = get_ride(mapElement->properties.track.ride_index);
+            ride = get_ride(tileElement->properties.track.ride_index);
             colour = RideKeyColours[RideColourKey[ride->type]];
             break;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     if ((colour & 0xFFFF) == 0)
         colour >>= 16;
diff --git a/src/openrct2-ui/windows/Staff.cpp b/src/openrct2-ui/windows/Staff.cpp
index 1e2a500063..0698404a3f 100644
--- a/src/openrct2-ui/windows/Staff.cpp
+++ b/src/openrct2-ui/windows/Staff.cpp
@@ -1132,14 +1132,14 @@ void window_staff_overview_tool_down(rct_window* w, rct_widgetindex widgetIndex,
 {
     if (widgetIndex == WIDX_PICKUP) {
         sint32 dest_x, dest_y;
-        rct_tile_element* mapElement;
-        footpath_get_coordinates_from_pos(x, y + 16, &dest_x, &dest_y, nullptr, &mapElement);
+        rct_tile_element* tileElement;
+        footpath_get_coordinates_from_pos(x, y + 16, &dest_x, &dest_y, nullptr, &tileElement);
 
         if (dest_x == LOCATION_NULL)
             return;
 
         game_command_callback = game_command_callback_pickup_staff;
-        game_do_command(w->number, GAME_COMMAND_FLAG_APPLY, 2, mapElement->base_height, GAME_COMMAND_PICKUP_STAFF, dest_x, dest_y);
+        game_do_command(w->number, GAME_COMMAND_FLAG_APPLY, 2, tileElement->base_height, GAME_COMMAND_PICKUP_STAFF, dest_x, dest_y);
     }
     else if (widgetIndex == WIDX_PATROL){
         sint32 dest_x, dest_y;
diff --git a/src/openrct2-ui/windows/StaffList.cpp b/src/openrct2-ui/windows/StaffList.cpp
index f3e0f6fa3f..f4e2efd434 100644
--- a/src/openrct2-ui/windows/StaffList.cpp
+++ b/src/openrct2-ui/windows/StaffList.cpp
@@ -336,8 +336,8 @@ static void window_staff_list_tooldown(rct_window *w, rct_widgetindex widgetInde
         sint32 selectedPeepType = _windowStaffListSelectedTab;
 
         sint32 direction;
-        rct_tile_element *mapElement;
-        footpath_get_coordinates_from_pos(x, y, &x, &y, &direction, &mapElement);
+        rct_tile_element *tileElement;
+        footpath_get_coordinates_from_pos(x, y, &x, &y, &direction, &tileElement);
         if (x == 0x8000)
             return;
 
diff --git a/src/openrct2-ui/windows/TitleCommandEditor.cpp b/src/openrct2-ui/windows/TitleCommandEditor.cpp
index 1f9b6447bd..81c036b8a3 100644
--- a/src/openrct2-ui/windows/TitleCommandEditor.cpp
+++ b/src/openrct2-ui/windows/TitleCommandEditor.cpp
@@ -169,9 +169,9 @@ static LocationXY16 get_location()
     rct_window *w = window_get_main();
     if (w != nullptr) {
         sint32 interactionType;
-        rct_tile_element *mapElement;
+        rct_tile_element *tileElement;
 
-        get_map_coordinates_from_pos_window(w, w->viewport->view_width / 2, w->viewport->view_height / 2, VIEWPORT_INTERACTION_MASK_TERRAIN, &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, nullptr);
+        get_map_coordinates_from_pos_window(w, w->viewport->view_width / 2, w->viewport->view_height / 2, VIEWPORT_INTERACTION_MASK_TERRAIN, &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, nullptr);
         mapCoord.x -= 16;
         mapCoord.x /= 32;
         mapCoord.y -= 16;
diff --git a/src/openrct2-ui/windows/TrackDesignPlace.cpp b/src/openrct2-ui/windows/TrackDesignPlace.cpp
index 7f2f954bd0..41b0f40eb4 100644
--- a/src/openrct2-ui/windows/TrackDesignPlace.cpp
+++ b/src/openrct2-ui/windows/TrackDesignPlace.cpp
@@ -406,24 +406,24 @@ static void window_track_place_clear_provisional()
  */
 static sint32 window_track_place_get_base_z(sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     sint32 z;
 
-    mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-    z = mapElement->base_height * 8;
+    tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+    z = tileElement->base_height * 8;
 
     // Increase Z above slope
-    if (mapElement->properties.surface.slope & 0x0F) {
+    if (tileElement->properties.surface.slope & 0x0F) {
         z += 16;
 
         // Increase Z above double slope
-        if (mapElement->properties.surface.slope & 0x10)
+        if (tileElement->properties.surface.slope & 0x10)
             z += 16;
     }
 
     // Increase Z above water
-    if (map_get_water_height(mapElement) > 0)
-        z = Math::Max(z, map_get_water_height(mapElement) << 4);
+    if (map_get_water_height(tileElement) > 0)
+        z = Math::Max(z, map_get_water_height(tileElement) << 4);
 
     return z + place_virtual_track(_trackDesign, PTD_OPERATION_GET_PLACE_Z, true, 0, x, y, z);
 }
diff --git a/src/openrct2/cheats.c b/src/openrct2/cheats.c
index 7ec69ef6e3..dd7f2294bb 100644
--- a/src/openrct2/cheats.c
+++ b/src/openrct2/cheats.c
@@ -60,21 +60,21 @@ sint32 park_rating_spinner_value;
 static void cheat_set_grass_length(sint32 length)
 {
     sint32 x, y;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     for (y = 0; y < 256; y++) {
         for (x = 0; x < 256; x++) {
-            mapElement = map_get_surface_element_at(x, y);
-            if (!(mapElement->properties.surface.ownership & OWNERSHIP_OWNED))
+            tileElement = map_get_surface_element_at(x, y);
+            if (!(tileElement->properties.surface.ownership & OWNERSHIP_OWNED))
                 continue;
 
-            if (tile_element_get_terrain(mapElement) != TERRAIN_GRASS)
+            if (tile_element_get_terrain(tileElement) != TERRAIN_GRASS)
                 continue;
 
-            if (map_get_water_height(mapElement) > 0)
+            if (map_get_water_height(tileElement) > 0)
                 continue;
 
-            mapElement->properties.surface.grass_length = length;
+            tileElement->properties.surface.grass_length = length;
         }
     }
 
diff --git a/src/openrct2/drawing/lightfx.c b/src/openrct2/drawing/lightfx.c
index 13ec3b2cf7..e96cb66d1f 100644
--- a/src/openrct2/drawing/lightfx.c
+++ b/src/openrct2/drawing/lightfx.c
@@ -278,13 +278,13 @@ void lightfx_prepare_light_list()
             for (sint32 pat = startSamplePoint; pat < totalSamplePoints; pat++) {
                 LocationXY16 mapCoord = { 0 };
 
-                rct_tile_element *mapElement = 0;
+                rct_tile_element *tileElement = 0;
 
                 sint32 interactionType = 0;
 
                 rct_window *w = window_get_main();
                 if (w != NULL) {
-                //  get_map_coordinates_from_pos(entry->x + offsetPattern[pat*2] / mapFrontDiv, entry->y + offsetPattern[pat*2+1] / mapFrontDiv, VIEWPORT_INTERACTION_MASK_NONE, &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, NULL);
+                //  get_map_coordinates_from_pos(entry->x + offsetPattern[pat*2] / mapFrontDiv, entry->y + offsetPattern[pat*2+1] / mapFrontDiv, VIEWPORT_INTERACTION_MASK_NONE, &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, NULL);
 
 #ifdef LIGHTFX_UNKNOWN_PART_1
                     _unk9AC154 = ~VIEWPORT_INTERACTION_MASK_SPRITE & 0xFFFF;
@@ -309,7 +309,7 @@ void lightfx_prepare_light_list()
                     mapCoord.x = _interactionMapX + tileOffsetX;
                     mapCoord.y = _interactionMapY + tileOffsetY;
                     interactionType = _interactionSpriteType;
-                    mapElement = RCT2_GLOBAL(0x9AC150, rct_tile_element*);
+                    tileElement = RCT2_GLOBAL(0x9AC150, rct_tile_element*);
 #endif //LIGHTFX_UNKNOWN_PART_1
 
                     //RCT2_GLOBAL(0x9AC154, uint16_t) = VIEWPORT_INTERACTION_MASK_NONE;
@@ -345,8 +345,8 @@ void lightfx_prepare_light_list()
                 sint32 minDist = 0;
                 sint32 baseHeight = -999;
 
-                if (interactionType != VIEWPORT_INTERACTION_ITEM_SPRITE && mapElement) {
-                    baseHeight = mapElement->base_height;
+                if (interactionType != VIEWPORT_INTERACTION_ITEM_SPRITE && tileElement) {
+                    baseHeight = tileElement->base_height;
                 }
 
                 minDist = ((baseHeight * 8) - coord_3d.z) / 2;
diff --git a/src/openrct2/game.c b/src/openrct2/game.c
index 58cfdc5317..1617412e16 100644
--- a/src/openrct2/game.c
+++ b/src/openrct2/game.c
@@ -1070,25 +1070,25 @@ void game_fix_save_vars()
     // and broken saves with incorrect invisible map border tiles
     for (sint32 y = 0; y < 256; y++) {
         for (sint32 x = 0; x < 256; x++) {
-            rct_tile_element *mapElement = map_get_surface_element_at(x, y);
+            rct_tile_element *tileElement = map_get_surface_element_at(x, y);
 
-            if (mapElement == NULL)
+            if (tileElement == NULL)
             {
                 log_error("Null map element at x = %d and y = %d. Fixing...", x, y);
-                mapElement = tile_element_insert(x, y, 14, 0);
-                if (mapElement == NULL) {
+                tileElement = tile_element_insert(x, y, 14, 0);
+                if (tileElement == NULL) {
                     log_error("Unable to fix: Map element limit reached.");
                     return;
                 }
             }
 
             // Fix the invisible border tiles.
-            // At this point, we can be sure that mapElement is not NULL.
+            // At this point, we can be sure that tileElement is not NULL.
             if (x == 0 || x == gMapSize - 1 || y == 0 || y == gMapSize -1)
             {
-                mapElement->base_height = 2;
-                mapElement->clearance_height = 2;
-                mapElement->properties.surface.slope = 0;
+                tileElement->base_height = 2;
+                tileElement->clearance_height = 2;
+                tileElement->properties.surface.slope = 0;
             }
         }
     }
diff --git a/src/openrct2/input.c b/src/openrct2/input.c
index a6803b1f00..fafaf971c8 100644
--- a/src/openrct2/input.c
+++ b/src/openrct2/input.c
@@ -85,7 +85,7 @@ void process_mouse_over(sint32 x, sint32 y);
 void process_mouse_tool(sint32 x, sint32 y);
 void invalidate_scroll();
 static rct_mouse_data* get_mouse_input();
-void tile_element_right_click(sint32 type, rct_tile_element *mapElement, sint32 x, sint32 y);
+void tile_element_right_click(sint32 type, rct_tile_element *tileElement, sint32 x, sint32 y);
 static void game_handle_input_mouse(sint32 x, sint32 y, sint32 state);
 static void input_widget_left(sint32 x, sint32 y, rct_window *w, rct_widgetindex widgetIndex);
 void input_state_widget_pressed(sint32 x, sint32 y, sint32 state, rct_widgetindex widgetIndex, rct_window* w, rct_widget* widget);
diff --git a/src/openrct2/interface/console.c b/src/openrct2/interface/console.c
index ddb285d241..aa8124bbbc 100644
--- a/src/openrct2/interface/console.c
+++ b/src/openrct2/interface/console.c
@@ -818,9 +818,9 @@ static sint32 cc_get(const utf8 **argv, sint32 argc)
             rct_window *w = window_get_main();
             if (w != NULL) {
                 sint32 interactionType;
-                rct_tile_element *mapElement;
+                rct_tile_element *tileElement;
                 LocationXY16 mapCoord = { 0 };
-                get_map_coordinates_from_pos(w->viewport->view_width / 2, w->viewport->view_height / 2, VIEWPORT_INTERACTION_MASK_TERRAIN, &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, NULL);
+                get_map_coordinates_from_pos(w->viewport->view_width / 2, w->viewport->view_height / 2, VIEWPORT_INTERACTION_MASK_TERRAIN, &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, NULL);
                 mapCoord.x -= 16;
                 mapCoord.x /= 32;
                 mapCoord.y -= 16;
@@ -1269,7 +1269,7 @@ static sint32 cc_remove_park_fences(const utf8 **argv, sint32 argc)
 static sint32 cc_show_limits(const utf8 ** argv, sint32 argc)
 {
     map_reorganise_elements();
-    sint32 mapElementCount = gNextFreeMapElement - gMapElements - 1;
+    sint32 tileElementCount = gNextFreeTileElement - gTileElements - 1;
 
     sint32 rideCount = 0;
     for (sint32 i = 0; i < MAX_RIDES; ++i) 
@@ -1306,7 +1306,7 @@ static sint32 cc_show_limits(const utf8 ** argv, sint32 argc)
     }
 
     console_printf("Sprites: %d/%d", spriteCount, MAX_SPRITES);
-    console_printf("Map Elements: %d/%d", mapElementCount, MAX_TILE_ELEMENTS);
+    console_printf("Map Elements: %d/%d", tileElementCount, MAX_TILE_ELEMENTS);
     console_printf("Banners: %d/%d", bannerCount, MAX_BANNERS);
     console_printf("Rides: %d/%d", rideCount, MAX_RIDES);
     console_printf("Staff: %d/%d", staffCount, STAFF_MAX_COUNT);
diff --git a/src/openrct2/interface/viewport.c b/src/openrct2/interface/viewport.c
index 066c10b9e8..53d61c5892 100644
--- a/src/openrct2/interface/viewport.c
+++ b/src/openrct2/interface/viewport.c
@@ -1025,7 +1025,7 @@ static void store_interaction_info(paint_struct *ps)
         _interactionSpriteType = ps->sprite_type;
         _interactionMapX = ps->map_x;
         _interactionMapY = ps->map_y;
-        _interaction_element = ps->mapElement;
+        _interaction_element = ps->tileElement;
     }
 }
 
@@ -1344,17 +1344,17 @@ static void sub_68862C(rct_drawpixelinfo * dpi, paint_struct * ps)
  * x: ax
  * y: cx
  * interactionType: bl
- * mapElement: edx
+ * tileElement: edx
  * viewport: edi
  */
-void get_map_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 flags, sint16 *x, sint16 *y, sint32 *interactionType, rct_tile_element **mapElement, rct_viewport **viewport)
+void get_map_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 flags, sint16 *x, sint16 *y, sint32 *interactionType, rct_tile_element **tileElement, rct_viewport **viewport)
 {
     rct_window* window = window_find_from_point(screenX, screenY);
-    get_map_coordinates_from_pos_window(window, screenX, screenY, flags, x, y, interactionType, mapElement, viewport);
+    get_map_coordinates_from_pos_window(window, screenX, screenY, flags, x, y, interactionType, tileElement, viewport);
 }
 
 void get_map_coordinates_from_pos_window(rct_window * window, sint32 screenX, sint32 screenY, sint32 flags, sint16 * x, sint16 * y,
-    sint32 * interactionType, rct_tile_element ** mapElement, rct_viewport ** viewport)
+    sint32 * interactionType, rct_tile_element ** tileElement, rct_viewport ** viewport)
 {
     _unk9AC154 = flags & 0xFFFF;
     _interactionSpriteType = 0;
@@ -1392,7 +1392,7 @@ void get_map_coordinates_from_pos_window(rct_window * window, sint32 screenX, si
     if (interactionType != NULL) *interactionType = _interactionSpriteType;
     if (x != NULL) *x = _interactionMapX;
     if (y != NULL) *y = _interactionMapY;
-    if (mapElement != NULL) *mapElement = _interaction_element;
+    if (tileElement != NULL) *tileElement = _interaction_element;
 }
 
 /**
diff --git a/src/openrct2/interface/viewport.h b/src/openrct2/interface/viewport.h
index d8c52236a5..eb639e07dc 100644
--- a/src/openrct2/interface/viewport.h
+++ b/src/openrct2/interface/viewport.h
@@ -80,7 +80,7 @@ typedef struct viewport_interaction_info {
     sint32 x;
     sint32 y;
     union {
-        rct_tile_element *mapElement;
+        rct_tile_element *tileElement;
         rct_sprite *sprite;
         rct_peep *peep;
         rct_vehicle *vehicle;
@@ -142,9 +142,9 @@ void show_construction_rights();
 void hide_construction_rights();
 void viewport_set_visibility(uint8 mode);
 
-void get_map_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 flags, sint16 *x, sint16 *y, sint32 *interactionType, rct_tile_element **mapElement, rct_viewport **viewport);
+void get_map_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 flags, sint16 *x, sint16 *y, sint32 *interactionType, rct_tile_element **tileElement, rct_viewport **viewport);
 void get_map_coordinates_from_pos_window(rct_window * window, sint32 screenX, sint32 screenY, sint32 flags, sint16 * x, sint16 * y,
-    sint32 * interactionType, rct_tile_element ** mapElement, rct_viewport ** viewport);
+    sint32 * interactionType, rct_tile_element ** tileElement, rct_viewport ** viewport);
 
 sint32 viewport_interaction_get_item_left(sint32 x, sint32 y, viewport_interaction_info *info);
 sint32 viewport_interaction_left_over(sint32 x, sint32 y);
@@ -152,9 +152,9 @@ sint32 viewport_interaction_left_click(sint32 x, sint32 y);
 sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interaction_info *info);
 sint32 viewport_interaction_right_over(sint32 x, sint32 y);
 sint32 viewport_interaction_right_click(sint32 x, sint32 y);
-void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *direction, rct_tile_element **mapElement);
+void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *direction, rct_tile_element **tileElement);
 
-void viewport_interaction_remove_park_entrance(rct_tile_element *mapElement, sint32 x, sint32 y);
+void viewport_interaction_remove_park_entrance(rct_tile_element *tileElement, sint32 x, sint32 y);
 
 void sub_68B2B7(paint_session * session, sint32 x, sint32 y);
 
diff --git a/src/openrct2/interface/viewport_interaction.c b/src/openrct2/interface/viewport_interaction.c
index 974a14b7f7..73a1e21829 100644
--- a/src/openrct2/interface/viewport_interaction.c
+++ b/src/openrct2/interface/viewport_interaction.c
@@ -33,11 +33,11 @@
 #include "viewport.h"
 #include "../Context.h"
 
-static void viewport_interaction_remove_scenery(rct_tile_element *mapElement, sint32 x, sint32 y);
-static void viewport_interaction_remove_footpath(rct_tile_element *mapElement, sint32 x, sint32 y);
-static void viewport_interaction_remove_footpath_item(rct_tile_element *mapElement, sint32 x, sint32 y);
-static void viewport_interaction_remove_park_wall(rct_tile_element *mapElement, sint32 x, sint32 y);
-static void viewport_interaction_remove_large_scenery(rct_tile_element *mapElement, sint32 x, sint32 y);
+static void viewport_interaction_remove_scenery(rct_tile_element *tileElement, sint32 x, sint32 y);
+static void viewport_interaction_remove_footpath(rct_tile_element *tileElement, sint32 x, sint32 y);
+static void viewport_interaction_remove_footpath_item(rct_tile_element *tileElement, sint32 x, sint32 y);
+static void viewport_interaction_remove_park_wall(rct_tile_element *tileElement, sint32 x, sint32 y);
+static void viewport_interaction_remove_large_scenery(rct_tile_element *tileElement, sint32 x, sint32 y);
 static rct_peep *viewport_interaction_get_closest_peep(sint32 x, sint32 y, sint32 maxDistance);
 
 /**
@@ -46,7 +46,7 @@ static rct_peep *viewport_interaction_get_closest_peep(sint32 x, sint32 y, sint3
  */
 sint32 viewport_interaction_get_item_left(sint32 x, sint32 y, viewport_interaction_info *info)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_sprite *sprite;
     rct_vehicle *vehicle;
 
@@ -59,11 +59,11 @@ sint32 viewport_interaction_get_item_left(sint32 x, sint32 y, viewport_interacti
         return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
 
     LocationXY16 mapCoord = { 0 };
-    get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_SPRITE & VIEWPORT_INTERACTION_MASK_RIDE & VIEWPORT_INTERACTION_MASK_PARK, &mapCoord.x, &mapCoord.y, &info->type, &info->mapElement, NULL);
+    get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_SPRITE & VIEWPORT_INTERACTION_MASK_RIDE & VIEWPORT_INTERACTION_MASK_PARK, &mapCoord.x, &mapCoord.y, &info->type, &info->tileElement, NULL);
     info->x = mapCoord.x;
     info->y = mapCoord.y;
-    mapElement = info->mapElement;
-    sprite = (rct_sprite*)mapElement;
+    tileElement = info->tileElement;
+    sprite = (rct_sprite*)tileElement;
 
     switch (info->type) {
     case VIEWPORT_INTERACTION_ITEM_SPRITE:
@@ -81,7 +81,7 @@ sint32 viewport_interaction_get_item_left(sint32 x, sint32 y, viewport_interacti
         }
         break;
     case VIEWPORT_INTERACTION_ITEM_RIDE:
-        ride_set_map_tooltip(mapElement);
+        ride_set_map_tooltip(tileElement);
         break;
     case VIEWPORT_INTERACTION_ITEM_PARK:
         set_map_tooltip_format_arg(0, rct_string_id, gParkName);
@@ -154,7 +154,7 @@ sint32 viewport_interaction_left_click(sint32 x, sint32 y)
         }
         return 1;
     case VIEWPORT_INTERACTION_ITEM_RIDE:
-        window_ride_open_track(info.mapElement);
+        window_ride_open_track(info.tileElement);
         return 1;
     case VIEWPORT_INTERACTION_ITEM_PARK:
         context_open_window(WC_PARK_INFORMATION);
@@ -170,7 +170,7 @@ sint32 viewport_interaction_left_click(sint32 x, sint32 y)
  */
 sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interaction_info *info)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_scenery_entry *sceneryEntry;
     rct_banner *banner;
     Ride *ride;
@@ -185,18 +185,18 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
         return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
 
     LocationXY16 mapCoord = { 0 };
-    get_map_coordinates_from_pos(x, y, ~(VIEWPORT_INTERACTION_MASK_TERRAIN & VIEWPORT_INTERACTION_MASK_WATER), &mapCoord.x, &mapCoord.y, &info->type, &info->mapElement, NULL);
+    get_map_coordinates_from_pos(x, y, ~(VIEWPORT_INTERACTION_MASK_TERRAIN & VIEWPORT_INTERACTION_MASK_WATER), &mapCoord.x, &mapCoord.y, &info->type, &info->tileElement, NULL);
     info->x = mapCoord.x;
     info->y = mapCoord.y;
-    mapElement = info->mapElement;
+    tileElement = info->tileElement;
 
     switch (info->type) {
     case VIEWPORT_INTERACTION_ITEM_SPRITE:
-        if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || mapElement->type != 0)
+        if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || tileElement->type != 0)
             return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
 
-        mapElement += 6;
-        ride = get_ride(mapElement->type);
+        tileElement += 6;
+        ride = get_ride(tileElement->type);
         if (ride->status == RIDE_STATUS_CLOSED) {
             set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
             set_map_tooltip_format_arg(2, rct_string_id, ride->name);
@@ -207,18 +207,18 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
     case VIEWPORT_INTERACTION_ITEM_RIDE:
         if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
             return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
             return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
 
-        ride = get_ride(mapElement->properties.track.ride_index);
+        ride = get_ride(tileElement->properties.track.ride_index);
         if (ride->status != RIDE_STATUS_CLOSED)
             return info->type;
 
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
             rct_string_id stringId;
-            if (mapElement->properties.track.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
+            if (tileElement->properties.track.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
                 if (ride->num_stations > 1) {
                     stringId = STR_RIDE_STATION_X_ENTRANCE;
                 } else {
@@ -232,7 +232,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
                 }
             }
             set_map_tooltip_format_arg(2, rct_string_id, stringId);
-        } else if (track_element_is_station(mapElement)) {
+        } else if (track_element_is_station(tileElement)) {
             rct_string_id stringId;
             if (ride->num_stations > 1) {
                 stringId = STR_RIDE_STATION_X;
@@ -241,7 +241,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
             }
             set_map_tooltip_format_arg(2, rct_string_id, stringId);
         } else {
-            if (!gCheatsSandboxMode && !map_is_location_owned(info->x, info->y, mapElement->base_height << 4)) {
+            if (!gCheatsSandboxMode && !map_is_location_owned(info->x, info->y, tileElement->base_height << 4)) {
                 return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
             }
 
@@ -254,7 +254,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
         set_map_tooltip_format_arg(6, uint32, ride->name_arguments);
         set_map_tooltip_format_arg(10, rct_string_id, RideComponentNames[RideNameConvention[ride->type].station].capitalised);
 
-        stationIndex = tile_element_get_station(mapElement);
+        stationIndex = tile_element_get_station(tileElement);
         for (i = stationIndex; i >= 0; i--)
             if (ride->station_starts[i].xy == RCT_XY8_UNDEFINED)
                 stationIndex--;
@@ -263,7 +263,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
         return info->type;
 
     case VIEWPORT_INTERACTION_ITEM_WALL:
-        sceneryEntry = get_wall_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
         if (sceneryEntry->wall.scrolling_mode != 255) {
             set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
             set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
@@ -272,7 +272,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
         break;
 
     case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
-        sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
+        sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
         if (sceneryEntry->large_scenery.scrolling_mode != 255) {
             set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
             set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
@@ -281,7 +281,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
         break;
 
     case VIEWPORT_INTERACTION_ITEM_BANNER:
-        banner = &gBanners[mapElement->properties.banner.index];
+        banner = &gBanners[tileElement->properties.banner.index];
         sceneryEntry = get_banner_entry(banner->type);
 
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
@@ -297,7 +297,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
 
     switch (info->type) {
     case VIEWPORT_INTERACTION_ITEM_SCENERY:
-        sceneryEntry = get_small_scenery_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_small_scenery_entry(tileElement->properties.scenery.type);
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
         set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
         return info->type;
@@ -305,14 +305,14 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH:
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
         set_map_tooltip_format_arg(2, rct_string_id, STR_FOOTPATH_MAP_TIP);
-        if (mapElement->type & 1)
+        if (tileElement->type & 1)
             set_map_tooltip_format_arg(2, rct_string_id, STR_QUEUE_LINE_MAP_TIP);
         return info->type;
 
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH_ITEM:
-        sceneryEntry = get_footpath_item_entry(footpath_element_get_path_scenery_index(mapElement));
+        sceneryEntry = get_footpath_item_entry(footpath_element_get_path_scenery_index(tileElement));
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN) {
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN) {
             set_map_tooltip_format_arg(2, rct_string_id, STR_BROKEN);
             set_map_tooltip_format_arg(4, rct_string_id, sceneryEntry->name);
         } else {
@@ -324,7 +324,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
         if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
             break;
 
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
             break;
 
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
@@ -332,13 +332,13 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
         return info->type;
 
     case VIEWPORT_INTERACTION_ITEM_WALL:
-        sceneryEntry = get_wall_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
         set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
         return info->type;
 
     case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
-        sceneryEntry = get_large_scenery_entry(mapElement->properties.scenery.type & 0x3FF);
+        sceneryEntry = get_large_scenery_entry(tileElement->properties.scenery.type & 0x3FF);
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
         set_map_tooltip_format_arg(2, rct_string_id, sceneryEntry->name);
         return info->type;
@@ -360,7 +360,7 @@ sint32 viewport_interaction_right_over(sint32 x, sint32 y)
  */
 sint32 viewport_interaction_right_click(sint32 x, sint32 y)
 {
-    rct_xy_element mapElement;
+    rct_xy_element tileElement;
     viewport_interaction_info info;
 
     switch (viewport_interaction_get_item_right(x, y, &info)) {
@@ -372,31 +372,31 @@ sint32 viewport_interaction_right_click(sint32 x, sint32 y)
             ride_construct(info.sprite->vehicle.ride);
         break;
     case VIEWPORT_INTERACTION_ITEM_RIDE:
-        mapElement.x = info.x;
-        mapElement.y = info.y;
-        mapElement.element = info.mapElement;
-        ride_modify(&mapElement);
+        tileElement.x = info.x;
+        tileElement.y = info.y;
+        tileElement.element = info.tileElement;
+        ride_modify(&tileElement);
         break;
     case VIEWPORT_INTERACTION_ITEM_SCENERY:
-        viewport_interaction_remove_scenery(info.mapElement, info.x, info.y);
+        viewport_interaction_remove_scenery(info.tileElement, info.x, info.y);
         break;
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH:
-        viewport_interaction_remove_footpath(info.mapElement, info.x, info.y);
+        viewport_interaction_remove_footpath(info.tileElement, info.x, info.y);
         break;
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH_ITEM:
-        viewport_interaction_remove_footpath_item(info.mapElement, info.x, info.y);
+        viewport_interaction_remove_footpath_item(info.tileElement, info.x, info.y);
         break;
     case VIEWPORT_INTERACTION_ITEM_PARK:
-        viewport_interaction_remove_park_entrance(info.mapElement, info.x, info.y);
+        viewport_interaction_remove_park_entrance(info.tileElement, info.x, info.y);
         break;
     case VIEWPORT_INTERACTION_ITEM_WALL:
-        viewport_interaction_remove_park_wall(info.mapElement, info.x, info.y);
+        viewport_interaction_remove_park_wall(info.tileElement, info.x, info.y);
         break;
     case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
-        viewport_interaction_remove_large_scenery(info.mapElement, info.x, info.y);
+        viewport_interaction_remove_large_scenery(info.tileElement, info.x, info.y);
         break;
     case VIEWPORT_INTERACTION_ITEM_BANNER:
-        context_open_detail_window(WD_BANNER, info.mapElement->properties.banner.index);
+        context_open_detail_window(WD_BANNER, info.tileElement->properties.banner.index);
         break;
     }
 
@@ -407,14 +407,14 @@ sint32 viewport_interaction_right_click(sint32 x, sint32 y)
  *
  *  rct2: 0x006E08D2
  */
-static void viewport_interaction_remove_scenery(rct_tile_element *mapElement, sint32 x, sint32 y)
+static void viewport_interaction_remove_scenery(rct_tile_element *tileElement, sint32 x, sint32 y)
 {
     gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
     game_do_command(
         x,
-        (mapElement->type << 8) | 1,
+        (tileElement->type << 8) | 1,
         y,
-        (mapElement->properties.scenery.type << 8) | mapElement->base_height,
+        (tileElement->properties.scenery.type << 8) | tileElement->base_height,
         GAME_COMMAND_REMOVE_SCENERY,
         0,
         0
@@ -425,46 +425,46 @@ static void viewport_interaction_remove_scenery(rct_tile_element *mapElement, si
  *
  *  rct2: 0x006A614A
  */
-static void viewport_interaction_remove_footpath(rct_tile_element *mapElement, sint32 x, sint32 y)
+static void viewport_interaction_remove_footpath(rct_tile_element *tileElement, sint32 x, sint32 y)
 {
     sint32 z;
     rct_window *w;
-    rct_tile_element *mapElement2;
+    rct_tile_element *tileElement2;
 
-    z = mapElement->base_height;
+    z = tileElement->base_height;
 
     w = window_find_by_class(WC_FOOTPATH);
     if (w != NULL)
         footpath_provisional_update();
 
-    mapElement2 = map_get_first_element_at(x / 32, y / 32);
+    tileElement2 = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(mapElement2) == TILE_ELEMENT_TYPE_PATH && mapElement2->base_height == z) {
+        if (tile_element_get_type(tileElement2) == TILE_ELEMENT_TYPE_PATH && tileElement2->base_height == z) {
             gGameCommandErrorTitle = STR_CANT_REMOVE_FOOTPATH_FROM_HERE;
             footpath_remove(x, y, z, 1);
             break;
         }
-    } while (!tile_element_is_last_for_tile(mapElement2++));
+    } while (!tile_element_is_last_for_tile(tileElement2++));
 }
 
 /**
  *
  *  rct2: 0x006A61AB
  */
-static void viewport_interaction_remove_footpath_item(rct_tile_element *mapElement, sint32 x, sint32 y)
+static void viewport_interaction_remove_footpath_item(rct_tile_element *tileElement, sint32 x, sint32 y)
 {
     sint32 type;
 
-    type = mapElement->properties.path.type >> 4;
-    if (mapElement->type & 1)
+    type = tileElement->properties.path.type >> 4;
+    if (tileElement->type & 1)
         type |= 0x80;
 
     gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
     game_do_command(
         x,
-        ((mapElement->properties.path.type & 7) << 8) | 1,
+        ((tileElement->properties.path.type & 7) << 8) | 1,
         y,
-        (type << 8) | mapElement->base_height,
+        (type << 8) | tileElement->base_height,
         GAME_COMMAND_PLACE_PATH,
         0,
         0
@@ -475,10 +475,10 @@ static void viewport_interaction_remove_footpath_item(rct_tile_element *mapEleme
  *
  *  rct2: 0x00666C0E
  */
-void viewport_interaction_remove_park_entrance(rct_tile_element *mapElement, sint32 x, sint32 y)
+void viewport_interaction_remove_park_entrance(rct_tile_element *tileElement, sint32 x, sint32 y)
 {
-    sint32 rotation = tile_element_get_direction_with_offset(mapElement, 1);
-    switch (mapElement->properties.entrance.index & 0x0F) {
+    sint32 rotation = tile_element_get_direction_with_offset(tileElement, 1);
+    switch (tileElement->properties.entrance.index & 0x0F) {
     case 1:
         x += TileDirectionDelta[rotation].x;
         y += TileDirectionDelta[rotation].y;
@@ -489,25 +489,25 @@ void viewport_interaction_remove_park_entrance(rct_tile_element *mapElement, sin
         break;
     }
     gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
-    game_do_command(x, GAME_COMMAND_FLAG_APPLY, y, mapElement->base_height / 2, GAME_COMMAND_REMOVE_PARK_ENTRANCE, 0, 0);
+    game_do_command(x, GAME_COMMAND_FLAG_APPLY, y, tileElement->base_height / 2, GAME_COMMAND_REMOVE_PARK_ENTRANCE, 0, 0);
 }
 
 /**
  *
  *  rct2: 0x006E57A9
  */
-static void viewport_interaction_remove_park_wall(rct_tile_element *mapElement, sint32 x, sint32 y)
+static void viewport_interaction_remove_park_wall(rct_tile_element *tileElement, sint32 x, sint32 y)
 {
-    rct_scenery_entry *sceneryEntry = get_wall_entry(mapElement->properties.wall.type);
+    rct_scenery_entry *sceneryEntry = get_wall_entry(tileElement->properties.wall.type);
     if (sceneryEntry->wall.scrolling_mode != 0xFF){
-        context_open_detail_window(WD_SIGN_SMALL, mapElement->properties.wall.banner_index);
+        context_open_detail_window(WD_SIGN_SMALL, tileElement->properties.wall.banner_index);
     } else {
         gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
         game_do_command(
             x,
             GAME_COMMAND_FLAG_APPLY,
             y,
-            tile_element_get_direction(mapElement) | (mapElement->base_height << 8),
+            tile_element_get_direction(tileElement) | (tileElement->base_height << 8),
             GAME_COMMAND_REMOVE_WALL,
             0,
             0
@@ -519,22 +519,22 @@ static void viewport_interaction_remove_park_wall(rct_tile_element *mapElement,
  *
  *  rct2: 0x006B88DC
  */
-static void viewport_interaction_remove_large_scenery(rct_tile_element *mapElement, sint32 x, sint32 y)
+static void viewport_interaction_remove_large_scenery(rct_tile_element *tileElement, sint32 x, sint32 y)
 {
-    rct_scenery_entry *sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
+    rct_scenery_entry *sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
 
     if (sceneryEntry->large_scenery.scrolling_mode != 0xFF){
-        sint32 id = (mapElement->type & 0xC0) |
-            ((mapElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) |
-            ((mapElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
+        sint32 id = (tileElement->type & 0xC0) |
+            ((tileElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) |
+            ((tileElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
         context_open_detail_window(WD_SIGN, id);
     } else {
         gGameCommandErrorTitle = STR_CANT_REMOVE_THIS;
         game_do_command(
             x,
-            1 | (tile_element_get_direction(mapElement) << 8),
+            1 | (tile_element_get_direction(tileElement) << 8),
             y,
-            mapElement->base_height | ((mapElement->properties.scenerymultiple.type >> 10) << 8),
+            tileElement->base_height | ((tileElement->properties.scenerymultiple.type >> 10) << 8),
             GAME_COMMAND_REMOVE_LARGE_SCENERY,
             0,
             0
@@ -586,13 +586,13 @@ static rct_peep *viewport_interaction_get_closest_peep(sint32 x, sint32 y, sint3
  *
  *  rct2: 0x0068A15E
  */
-void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *direction, rct_tile_element **mapElement)
+void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *direction, rct_tile_element **tileElement)
 {
     sint16 my_x, my_y;
     sint32 interactionType;
-    rct_tile_element *myMapElement;
+    rct_tile_element *myTileElement;
     rct_viewport *viewport;
-    get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_TERRAIN & VIEWPORT_INTERACTION_MASK_WATER, &my_x, &my_y, &interactionType, &myMapElement, &viewport);
+    get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_TERRAIN & VIEWPORT_INTERACTION_MASK_WATER, &my_x, &my_y, &interactionType, &myTileElement, &viewport);
 
     if (interactionType == VIEWPORT_INTERACTION_ITEM_NONE) {
         *x = LOCATION_NULL;
@@ -601,7 +601,7 @@ void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *di
 
     sint16 originalZ = 0;
     if (interactionType == VIEWPORT_INTERACTION_ITEM_WATER) {
-        originalZ = map_get_water_height(myMapElement) << 4;
+        originalZ = map_get_water_height(myTileElement) << 4;
     }
 
     LocationXY16 start_vp_pos = screen_coord_to_viewport_coord(viewport, screenX, screenY);
@@ -638,5 +638,5 @@ void sub_68A15E(sint32 screenX, sint32 screenY, sint16 *x, sint16 *y, sint32 *di
     *x = map_pos.x & ~0x1F;
     *y = map_pos.y & ~0x1F;
     if (direction != NULL) *direction = myDirection;
-    if (mapElement != NULL) *mapElement = myMapElement;
+    if (tileElement != NULL) *tileElement = myTileElement;
 }
diff --git a/src/openrct2/interface/window.h b/src/openrct2/interface/window.h
index 31bf65e4b8..e495ab4cb3 100644
--- a/src/openrct2/interface/window.h
+++ b/src/openrct2/interface/window.h
@@ -719,7 +719,7 @@ void window_game_bottom_toolbar_invalidate_news_item();
 void window_track_list_open(ride_list_item item);
 rct_window *window_ride_main_open(sint32 rideIndex);
 rct_window *window_ride_open_station(sint32 rideIndex, sint32 stationIndex);
-rct_window *window_ride_open_track(rct_tile_element *mapElement);
+rct_window *window_ride_open_track(rct_tile_element *tileElement);
 rct_window *window_ride_open_vehicle(rct_vehicle *vehicle);
 void window_ride_construct(rct_window *w);
 rct_window *window_ride_construction_open();
diff --git a/src/openrct2/paint/Paint.cpp b/src/openrct2/paint/Paint.cpp
index ae2f9b0e27..44ba492a3e 100644
--- a/src/openrct2/paint/Paint.cpp
+++ b/src/openrct2/paint/Paint.cpp
@@ -188,7 +188,7 @@ static paint_struct * sub_9819_c(paint_session * session, uint32 image_id, Locat
     ps->var_29 = 0;
     ps->map_x = session->MapPosition.x;
     ps->map_y = session->MapPosition.y;
-    ps->mapElement = (rct_tile_element*)session->CurrentlyDrawnItem;
+    ps->tileElement = (rct_tile_element*)session->CurrentlyDrawnItem;
 
     return ps;
 }
@@ -847,7 +847,7 @@ extern "C"
         ps->var_29 = 0;
         ps->map_x = session->MapPosition.x;
         ps->map_y = session->MapPosition.y;
-        ps->mapElement = (rct_tile_element*)session->CurrentlyDrawnItem;
+        ps->tileElement = (rct_tile_element*)session->CurrentlyDrawnItem;
 
         session->UnkF1AD28 = ps;
 
diff --git a/src/openrct2/paint/paint.h b/src/openrct2/paint/paint.h
index 879a136166..b83759c4a6 100644
--- a/src/openrct2/paint/paint.h
+++ b/src/openrct2/paint/paint.h
@@ -81,7 +81,7 @@ struct paint_struct {
     uint16 pad_2A;
     uint16 map_x;           // 0x2C
     uint16 map_y;           // 0x2E
-    rct_tile_element *mapElement; // 0x30 (or sprite pointer)
+    rct_tile_element *tileElement; // 0x30 (or sprite pointer)
 };
 #ifdef PLATFORM_32BIT
 // TODO: drop packing from this when all rendering is done.
diff --git a/src/openrct2/paint/tile_element/path.c b/src/openrct2/paint/tile_element/path.c
index fd92419563..ae0ffd8689 100644
--- a/src/openrct2/paint/tile_element/path.c
+++ b/src/openrct2/paint/tile_element/path.c
@@ -77,12 +77,12 @@ static const uint8 byte_98D8A4[] = {
     0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0
 };
 
-void path_paint_pole_support(paint_session * session, rct_tile_element * mapElement, sint32 height, rct_footpath_entry * footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags);
-void path_paint_box_support(paint_session * session, rct_tile_element* mapElement, sint16 height, rct_footpath_entry* footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags);
+void path_paint_pole_support(paint_session * session, rct_tile_element * tileElement, sint32 height, rct_footpath_entry * footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags);
+void path_paint_box_support(paint_session * session, rct_tile_element* tileElement, sint16 height, rct_footpath_entry* footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags);
 
 /* rct2: 0x006A5AE5 */
-static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* mapElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
-    if (footpath_element_is_sloped(mapElement))
+static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* tileElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
+    if (footpath_element_is_sloped(tileElement))
         height += 8;
 
     uint32 imageId;
@@ -90,7 +90,7 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
     if (!(edges & (1 << 0))) {
         imageId = pathBitEntry->image + 1;
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
             imageId += 4;
 
         imageId |= pathBitImageFlags;
@@ -100,7 +100,7 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
     if (!(edges & (1 << 1))) {
         imageId = pathBitEntry->image + 2;
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
             imageId += 4;
 
         imageId |= pathBitImageFlags;
@@ -111,7 +111,7 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
     if (!(edges & (1 << 2))) {
         imageId = pathBitEntry->image + 3;
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
             imageId += 4;
 
         imageId |= pathBitImageFlags;
@@ -122,7 +122,7 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
     if (!(edges & (1 << 3))) {
         imageId = pathBitEntry->image + 4;
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
             imageId += 4;
 
         imageId |= pathBitImageFlags;
@@ -132,8 +132,8 @@ static void path_bit_lights_paint(paint_session * session, rct_scenery_entry* pa
 }
 
 /* rct2: 0x006A5C94 */
-static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* mapElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
-    if (footpath_element_is_sloped(mapElement))
+static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* tileElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
+    if (footpath_element_is_sloped(tileElement))
         height += 8;
 
     uint32 imageId;
@@ -143,12 +143,12 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
 
         imageId |= pathBitImageFlags;
 
-        if (!(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
+        if (!(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
             imageId -= 4;
 
             // Edges have been rotated around the rotation to check addition status
             // this will also need to be rotated.
-            if (!(mapElement->properties.path.addition_status & ror8(0x3,(2 * get_current_rotation()))))
+            if (!(tileElement->properties.path.addition_status & ror8(0x3,(2 * get_current_rotation()))))
                 imageId += 8;
         }
 
@@ -160,12 +160,12 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
 
         imageId |= pathBitImageFlags;
 
-        if (!(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
+        if (!(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
             imageId -= 4;
 
             // Edges have been rotated around the rotation to check addition status
             // this will also need to be rotated.
-            if (!(mapElement->properties.path.addition_status & ror8(0xC, (2 * get_current_rotation()))))
+            if (!(tileElement->properties.path.addition_status & ror8(0xC, (2 * get_current_rotation()))))
                 imageId += 8;
         }
 
@@ -178,12 +178,12 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
 
         imageId |= pathBitImageFlags;
 
-        if (!(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
+        if (!(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
             imageId -= 4;
 
             // Edges have been rotated around the rotation to check addition status
             // this will also need to be rotated.
-            if (!(mapElement->properties.path.addition_status & ror8(0x30, (2 * get_current_rotation()))))
+            if (!(tileElement->properties.path.addition_status & ror8(0x30, (2 * get_current_rotation()))))
                 imageId += 8;
         }
 
@@ -196,12 +196,12 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
 
         imageId |= pathBitImageFlags;
 
-        if (!(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
+        if (!(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)) {
             imageId -= 4;
 
             // Edges have been rotated around the rotation to check addition status
             // this will also need to be rotated.
-            if (!(mapElement->properties.path.addition_status & ror8(0xC0, (2 * get_current_rotation()))))
+            if (!(tileElement->properties.path.addition_status & ror8(0xC0, (2 * get_current_rotation()))))
                 imageId += 8;
         }
 
@@ -211,13 +211,13 @@ static void path_bit_bins_paint(paint_session * session, rct_scenery_entry* path
 }
 
 /* rct2: 0x006A5E81 */
-static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* mapElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
+static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* tileElement, sint32 height, uint8 edges, uint32 pathBitImageFlags) {
     uint32 imageId;
 
     if (!(edges & (1 << 0))) {
         imageId = pathBitEntry->image + 1;
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
             imageId += 4;
 
         imageId |= pathBitImageFlags;
@@ -227,7 +227,7 @@ static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* p
     if (!(edges & (1 << 1))) {
         imageId = pathBitEntry->image + 2;
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
             imageId += 4;
 
         imageId |= pathBitImageFlags;
@@ -238,7 +238,7 @@ static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* p
     if (!(edges & (1 << 2))) {
         imageId = pathBitEntry->image + 3;
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
             imageId += 4;
 
         imageId |= pathBitImageFlags;
@@ -249,7 +249,7 @@ static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* p
     if (!(edges & (1 << 3))) {
         imageId = pathBitEntry->image + 4;
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
             imageId += 4;
 
         imageId |= pathBitImageFlags;
@@ -259,7 +259,7 @@ static void path_bit_benches_paint(paint_session * session, rct_scenery_entry* p
 }
 
 /* rct2: 0x006A6008 */
-static void path_bit_jumping_fountains_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* mapElement, sint32 height, uint8 edges, uint32 pathBitImageFlags, rct_drawpixelinfo* dpi) {
+static void path_bit_jumping_fountains_paint(paint_session * session, rct_scenery_entry* pathBitEntry, rct_tile_element* tileElement, sint32 height, uint8 edges, uint32 pathBitImageFlags, rct_drawpixelinfo* dpi) {
     if (dpi->zoom_level != 0)
         return;
 
@@ -793,14 +793,14 @@ void path_paint(paint_session * session, uint8 direction, uint16 height, rct_til
 #endif
 }
 
-void path_paint_pole_support(paint_session * session, rct_tile_element * mapElement, sint32 height, rct_footpath_entry * footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags)
+void path_paint_pole_support(paint_session * session, rct_tile_element * tileElement, sint32 height, rct_footpath_entry * footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags)
 {
     // Rol edges around rotation
-    uint8 edges = ((mapElement->properties.path.edges << get_current_rotation()) & 0xF) |
-        (((mapElement->properties.path.edges & 0xF) << get_current_rotation()) >> 4);
+    uint8 edges = ((tileElement->properties.path.edges << get_current_rotation()) & 0xF) |
+        (((tileElement->properties.path.edges & 0xF) << get_current_rotation()) >> 4);
 
-    uint8 corners = (((mapElement->properties.path.edges >> 4) << get_current_rotation()) & 0xF) |
-        (((mapElement->properties.path.edges >> 4) << get_current_rotation()) >> 4);
+    uint8 corners = (((tileElement->properties.path.edges >> 4) << get_current_rotation()) & 0xF) |
+        (((tileElement->properties.path.edges >> 4) << get_current_rotation()) >> 4);
 
 
     LocationXY16 boundBoxOffset = {.x =stru_98D804[edges][0], .y = stru_98D804[edges][1]};
@@ -809,14 +809,14 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
     uint16 edi = edges | (corners << 4);
 
     uint32 imageId;
-    if (footpath_element_is_sloped(mapElement)) {
-        imageId = ((mapElement->properties.path.type + get_current_rotation()) & 3) + 16;
+    if (footpath_element_is_sloped(tileElement)) {
+        imageId = ((tileElement->properties.path.type + get_current_rotation()) & 3) + 16;
     } else {
         imageId = byte_98D6E0[edi];
     }
 
     imageId += footpathEntry->image;
-    if (footpath_element_is_queue(mapElement)) {
+    if (footpath_element_is_queue(tileElement)) {
         imageId += 51;
     }
 
@@ -831,15 +831,15 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
         sub_98197C(session, imageId | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
     } else {
         uint32 image_id;
-        if (footpath_element_is_sloped(mapElement)) {
-            image_id = ((mapElement->properties.path.type + get_current_rotation()) & 3) + footpathEntry->bridge_image + 51;
+        if (footpath_element_is_sloped(tileElement)) {
+            image_id = ((tileElement->properties.path.type + get_current_rotation()) & 3) + footpathEntry->bridge_image + 51;
         } else {
             image_id = byte_98D8A4[edges] + footpathEntry->bridge_image + 49;
         }
 
         sub_98197C(session, image_id | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
 
-        if (!footpath_element_is_queue(mapElement) && !(footpathEntry->flags & FOOTPATH_ENTRY_FLAG_HAS_PATH_BASE_SPRITE)) {
+        if (!footpath_element_is_queue(tileElement) && !(footpathEntry->flags & FOOTPATH_ENTRY_FLAG_HAS_PATH_BASE_SPRITE)) {
             // don't draw
         } else {
             sub_98199C(session, imageId | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
@@ -847,11 +847,11 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
     }
 
 
-    sub_6A3F61(session, mapElement, edi, height, footpathEntry, imageFlags, sceneryImageFlags, hasFences);
+    sub_6A3F61(session, tileElement, edi, height, footpathEntry, imageFlags, sceneryImageFlags, hasFences);
 
     uint16 ax = 0;
-    if (footpath_element_is_sloped(mapElement)) {
-        ax = ((mapElement->properties.path.type + get_current_rotation()) & 0x3) + 1;
+    if (footpath_element_is_sloped(tileElement)) {
+        ax = ((tileElement->properties.path.type + get_current_rotation()) & 0x3) + 1;
     }
 
     if (byte_98D8A4[edges] == 0) {
@@ -861,20 +861,20 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
     }
 
     height += 32;
-    if (footpath_element_is_sloped(mapElement)) {
+    if (footpath_element_is_sloped(tileElement)) {
         height += 16;
     }
 
     paint_util_set_general_support_height(session, height, 0x20);
 
-    if (footpath_element_is_queue(mapElement)
-        || (mapElement->properties.path.edges != 0xFF && hasFences)
+    if (footpath_element_is_queue(tileElement)
+        || (tileElement->properties.path.edges != 0xFF && hasFences)
         ) {
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         return;
     }
 
-    if (mapElement->properties.path.edges == 0xFF) {
+    if (tileElement->properties.path.edges == 0xFF) {
         paint_util_set_segment_support_height(session, SEGMENT_C8 | SEGMENT_CC | SEGMENT_D0 | SEGMENT_D4, 0xFFFF, 0);
         return;
     }
@@ -898,11 +898,11 @@ void path_paint_pole_support(paint_session * session, rct_tile_element * mapElem
     }
 }
 
-void path_paint_box_support(paint_session * session, rct_tile_element* mapElement, sint16 height, rct_footpath_entry* footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags)
+void path_paint_box_support(paint_session * session, rct_tile_element* tileElement, sint16 height, rct_footpath_entry* footpathEntry, bool hasFences, uint32 imageFlags, uint32 sceneryImageFlags)
 {
     // Rol edges around rotation
-    uint8 edges = ((mapElement->properties.path.edges << get_current_rotation()) & 0xF) |
-        (((mapElement->properties.path.edges & 0xF) << get_current_rotation()) >> 4);
+    uint8 edges = ((tileElement->properties.path.edges << get_current_rotation()) & 0xF) |
+        (((tileElement->properties.path.edges & 0xF) << get_current_rotation()) >> 4);
 
     LocationXY16 boundBoxOffset = {
         .x = stru_98D804[edges][0],
@@ -914,14 +914,14 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
         .y = stru_98D804[edges][3]
     };
 
-    uint8 corners = (((mapElement->properties.path.edges >> 4) << get_current_rotation()) & 0xF) |
-        (((mapElement->properties.path.edges >> 4) << get_current_rotation()) >> 4);
+    uint8 corners = (((tileElement->properties.path.edges >> 4) << get_current_rotation()) & 0xF) |
+        (((tileElement->properties.path.edges >> 4) << get_current_rotation()) >> 4);
 
     uint16 edi = edges | (corners << 4);
 
     uint32 imageId;
-    if (footpath_element_is_sloped(mapElement)) {
-        imageId = ((mapElement->properties.path.type + get_current_rotation()) & 3) + 16;
+    if (footpath_element_is_sloped(tileElement)) {
+        imageId = ((tileElement->properties.path.type + get_current_rotation()) & 3) + 16;
     }
     else {
         imageId = byte_98D6E0[edi];
@@ -929,7 +929,7 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
 
 
     imageId += footpathEntry->image;
-    if (footpath_element_is_queue(mapElement)) {
+    if (footpath_element_is_queue(tileElement)) {
         imageId += 51;
     }
 
@@ -946,8 +946,8 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
     }
     else {
         uint32 bridgeImage;
-        if (footpath_element_is_sloped(mapElement)) {
-            bridgeImage = ((mapElement->properties.path.type + get_current_rotation()) & 3) + footpathEntry->bridge_image + 16;
+        if (footpath_element_is_sloped(tileElement)) {
+            bridgeImage = ((tileElement->properties.path.type + get_current_rotation()) & 3) + footpathEntry->bridge_image + 16;
         }
         else {
             bridgeImage = edges + footpathEntry->bridge_image;
@@ -956,15 +956,15 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
 
         sub_98197C(session, bridgeImage | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
 
-        if (footpath_element_is_queue(mapElement) || (footpathEntry->flags & FOOTPATH_ENTRY_FLAG_HAS_PATH_BASE_SPRITE)) {
+        if (footpath_element_is_queue(tileElement) || (footpathEntry->flags & FOOTPATH_ENTRY_FLAG_HAS_PATH_BASE_SPRITE)) {
             sub_98199C(session, imageId | imageFlags, 0, 0, boundBoxSize.x, boundBoxSize.y, 0, height, boundBoxOffset.x, boundBoxOffset.y, height + 1, get_current_rotation());
         }
     }
 
-    sub_6A3F61(session, mapElement, edi, height, footpathEntry, imageFlags, sceneryImageFlags, hasFences); // TODO: arguments
+    sub_6A3F61(session, tileElement, edi, height, footpathEntry, imageFlags, sceneryImageFlags, hasFences); // TODO: arguments
 
     uint16 ax = 0;
-    if (footpath_element_is_sloped(mapElement)) {
+    if (footpath_element_is_sloped(tileElement)) {
         ax = 8;
     }
 
@@ -982,21 +982,21 @@ void path_paint_box_support(paint_session * session, rct_tile_element* mapElemen
     }
 
     height += 32;
-    if (footpath_element_is_sloped(mapElement)) {
+    if (footpath_element_is_sloped(tileElement)) {
         height += 16;
     }
 
     paint_util_set_general_support_height(session, height, 0x20);
 
-    if (footpath_element_is_queue(mapElement)
-        || (mapElement->properties.path.edges != 0xFF && hasFences)
+    if (footpath_element_is_queue(tileElement)
+        || (tileElement->properties.path.edges != 0xFF && hasFences)
         ) {
 
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         return;
     }
 
-    if (mapElement->properties.path.edges == 0xFF) {
+    if (tileElement->properties.path.edges == 0xFF) {
         paint_util_set_segment_support_height(session, SEGMENT_C8 | SEGMENT_CC | SEGMENT_D0 | SEGMENT_D4, 0xFFFF, 0);
         return;
     }
diff --git a/src/openrct2/paint/tile_element/scenery.c b/src/openrct2/paint/tile_element/scenery.c
index dae2a65a2f..036e18148d 100644
--- a/src/openrct2/paint/tile_element/scenery.c
+++ b/src/openrct2/paint/tile_element/scenery.c
@@ -42,8 +42,8 @@ static const LocationXY16 lengths[] = {
  *
  *  rct2: 0x006DFF47
  */
-void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* mapElement) {
-    //RCT2_CALLPROC_X(0x6DFF47, 0, 0, direction, height, (sint32)mapElement, 0, 0); return;
+void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tileElement) {
+    //RCT2_CALLPROC_X(0x6DFF47, 0, 0, direction, height, (sint32)tileElement, 0, 0); return;
     session->InteractionType = VIEWPORT_INTERACTION_ITEM_SCENERY;
     LocationXYZ16 boxlength;
     LocationXYZ16 boxoffset;
@@ -53,17 +53,17 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
     sint32 baseImageid = 0;
     const sint32 rotation = get_current_rotation();
     if (gTrackDesignSaveMode) {
-        if (!track_design_save_contains_tile_element(mapElement)) {
+        if (!track_design_save_contains_tile_element(tileElement)) {
             baseImageid = 0x21700000;
         }
     }
-    if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST) {
+    if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST) {
         session->InteractionType = VIEWPORT_INTERACTION_ITEM_NONE;
         baseImageid = construction_markers[gConfigGeneral.construction_marker_colour];
     }
     uint32 dword_F64EB0 = baseImageid;
 
-    rct_scenery_entry *entry = get_small_scenery_entry(mapElement->properties.scenery.type);
+    rct_scenery_entry *entry = get_small_scenery_entry(tileElement->properties.scenery.type);
 
     if (entry == NULL)
     {
@@ -104,7 +104,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
         }
     } else {
         // 6DFFC2:
-        uint8 ecx = (tile_element_get_scenery_quadrant(mapElement) + rotation) & 3;
+        uint8 ecx = (tile_element_get_scenery_quadrant(tileElement) + rotation) & 3;
         x_offset = ScenerySubTileOffsets[ecx].x;
         y_offset = ScenerySubTileOffsets[ecx].y;
         boxoffset.x = x_offset;
@@ -116,10 +116,10 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
         boxlength.z = 128;
     }
     if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_CAN_WITHER) {
-        if (mapElement->properties.scenery.age >= 40) {
+        if (tileElement->properties.scenery.age >= 40) {
             baseImageid += 4;
         }
-        if (mapElement->properties.scenery.age >= 55) {
+        if (tileElement->properties.scenery.age >= 55) {
             baseImageid += 4;
         }
     }
@@ -127,12 +127,12 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
     {
         if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_HAS_SECONDARY_COLOUR)
         {
-            baseImageid |= SPRITE_ID_PALETTE_COLOUR_2(scenery_small_get_primary_colour(mapElement),
-                                                      scenery_small_get_secondary_colour(mapElement));
+            baseImageid |= SPRITE_ID_PALETTE_COLOUR_2(scenery_small_get_primary_colour(tileElement),
+                                                      scenery_small_get_secondary_colour(tileElement));
         }
         else
         {
-            baseImageid |= SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(mapElement));
+            baseImageid |= SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(tileElement));
         }
     }
     if (dword_F64EB0 != 0) {
@@ -146,7 +146,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
         if (dword_F64EB0 == 0) {
             // Draw translucent overlay:
             // TODO: Name palette entries
-            sint32 image_id = (baseImageid & 0x7FFFF) + (GlassPaletteIds[scenery_small_get_primary_colour(mapElement)] << 19) + 0x40000004;
+            sint32 image_id = (baseImageid & 0x7FFFF) + (GlassPaletteIds[scenery_small_get_primary_colour(tileElement)] << 19) + 0x40000004;
             sub_98199C(session, image_id, x_offset, y_offset, boxlength.x, boxlength.y, boxlength.z - 1, height, boxoffset.x, boxoffset.y, boxoffset.z, rotation);
         }
     }
@@ -233,7 +233,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
                 if (!(entry->small_scenery.flags & SMALL_SCENERY_FLAG_COG)) {
                     // 6E01F8:
                     frame += ((session->SpritePosition.x / 4) + (session->SpritePosition.y / 4));
-                    frame += (mapElement->type & 0xC0) / 16;
+                    frame += (tileElement->type & 0xC0) / 16;
                 }
                 // 6E0222:
                 uint16 delay = entry->small_scenery.animation_delay & 0xFF;
@@ -250,12 +250,12 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
                 if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_HAS_PRIMARY_COLOUR)
                 {
                     if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_HAS_SECONDARY_COLOUR) {
-                        image_id |= SPRITE_ID_PALETTE_COLOUR_2(scenery_small_get_primary_colour(mapElement),
-                                                               scenery_small_get_secondary_colour(mapElement));
+                        image_id |= SPRITE_ID_PALETTE_COLOUR_2(scenery_small_get_primary_colour(tileElement),
+                                                               scenery_small_get_secondary_colour(tileElement));
                     }
                     else
                     {
-                        image_id |= SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(mapElement));
+                        image_id |= SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(tileElement));
                     }
                 }
                 if (dword_F64EB0 != 0) {
@@ -271,7 +271,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
         }
     }
     // 6E0556: Draw supports:
-    if (scenery_small_get_supports_needed(mapElement)) {
+    if (scenery_small_get_supports_needed(tileElement)) {
         if (!(entry->small_scenery.flags & SMALL_SCENERY_FLAG_NO_SUPPORTS)) {
             sint32 ax = 0;
             sint32 supportHeight = height;
@@ -282,7 +282,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
             uint32 supportImageColourFlags = IMAGE_TYPE_REMAP;
             if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_PAINT_SUPPORTS)
             {
-                supportImageColourFlags = SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(mapElement));
+                supportImageColourFlags = SPRITE_ID_PALETTE_COLOUR_1(scenery_small_get_primary_colour(tileElement));
             }
             if (dword_F64EB0 != 0) {
                 supportImageColourFlags = dword_F64EB0;
@@ -310,7 +310,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
         }
         if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_VOFFSET_CENTRE) {
             // 6E075C:
-            direction = (tile_element_get_scenery_quadrant(mapElement) + rotation) % 4;
+            direction = (tile_element_get_scenery_quadrant(tileElement) + rotation) % 4;
             paint_util_set_segment_support_height(session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C8 | SEGMENT_CC, direction), height, 0x20);
             return;
         }
@@ -324,7 +324,7 @@ void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_
         return;
     }
     if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_VOFFSET_CENTRE) {
-        direction = (tile_element_get_scenery_quadrant(mapElement) + rotation) % 4;
+        direction = (tile_element_get_scenery_quadrant(tileElement) + rotation) % 4;
         paint_util_set_segment_support_height(session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         return;
     }
diff --git a/src/openrct2/paint/tile_element/scenery_multiple.c b/src/openrct2/paint/tile_element/scenery_multiple.c
index f85ee7dbb8..b5cda9a070 100644
--- a/src/openrct2/paint/tile_element/scenery_multiple.c
+++ b/src/openrct2/paint/tile_element/scenery_multiple.c
@@ -26,7 +26,7 @@
 #include "../../world/scenery.h"
 
 // 6B8172:
-static void scenery_multiple_paint_supports(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement, uint32 dword_F4387C, rct_large_scenery_tile *tile)
+static void scenery_multiple_paint_supports(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement, uint32 dword_F4387C, rct_large_scenery_tile *tile)
 {
     if (tile->var_7 & 0x20) {
         return;
@@ -48,7 +48,7 @@ static void scenery_multiple_paint_supports(paint_session * session, uint8 direc
 
     wooden_b_supports_paint_setup(session, (direction & 1), ax, supportHeight, supportImageColourFlags, NULL);
 
-    sint32 clearanceHeight = ceil2(mapElement->clearance_height * 8 + 15, 16);
+    sint32 clearanceHeight = ceil2(tileElement->clearance_height * 8 + 15, 16);
 
     if (tile->var_7 & 0x40) {
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, clearanceHeight, 0x20);
@@ -183,29 +183,29 @@ static const boundbox s98E3C4[] = {
 *
 * rct2: 0x006B7F0C
 */
-void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement) {
-    //RCT2_CALLPROC_X(0x6B7F0C, 0, 0, direction, height, (sint32)mapElement, 0, 0); return;
+void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement) {
+    //RCT2_CALLPROC_X(0x6B7F0C, 0, 0, direction, height, (sint32)tileElement, 0, 0); return;
     session->InteractionType = VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY;
-    uint32 ebp = mapElement->properties.scenerymultiple.type >> 10;
-    rct_scenery_entry *entry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
+    uint32 ebp = tileElement->properties.scenerymultiple.type >> 10;
+    rct_scenery_entry *entry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
     if (entry == NULL)
         return;
 
     uint32 image_id = (ebp << 2) + entry->image + 4 + direction;
     rct_large_scenery_tile *tile = &entry->large_scenery.tiles[ebp];
     uint32 dword_F4387C = 0;
-    image_id |= ((mapElement->properties.scenerymultiple.colour[0] & 0x1F) << 19) | ((mapElement->properties.scenerymultiple.colour[1] & 0x1F) << 24) | IMAGE_TYPE_REMAP | IMAGE_TYPE_REMAP_2_PLUS;
+    image_id |= ((tileElement->properties.scenerymultiple.colour[0] & 0x1F) << 19) | ((tileElement->properties.scenerymultiple.colour[1] & 0x1F) << 24) | IMAGE_TYPE_REMAP | IMAGE_TYPE_REMAP_2_PLUS;
     LocationXYZ16 boxlength;
     LocationXYZ16 boxoffset;
     if (gTrackDesignSaveMode) {
-        if (!track_design_save_contains_tile_element(mapElement)) {
+        if (!track_design_save_contains_tile_element(tileElement)) {
             ebp = 0x21700000;
             image_id &= 0x7FFFF;
             dword_F4387C = ebp;
             image_id |= dword_F4387C;
         }
     }
-    if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST) {
+    if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST) {
         session->InteractionType = VIEWPORT_INTERACTION_ITEM_NONE;
         ebp = construction_markers[gConfigGeneral.construction_marker_colour];
         image_id &= 0x7FFFF;
@@ -232,32 +232,32 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
     boxlength.z = ah;
     sub_98197C(session, image_id, 0, 0, boxlength.x, boxlength.y, ah, height, boxoffset.x, boxoffset.y, boxoffset.z, get_current_rotation());
     if (entry->large_scenery.scrolling_mode == 0xFF || direction == 1 || direction == 2) {
-        scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
+        scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
         return;
     }
     if (entry->large_scenery.flags & LARGE_SCENERY_FLAG_3D_TEXT) {
         if (entry->large_scenery.tiles[1].x_offset != (sint16)(uint16)0xFFFF) {
-            sint32 al = ((mapElement->properties.surface.terrain >> 2) - 1) & 3;
+            sint32 al = ((tileElement->properties.surface.terrain >> 2) - 1) & 3;
             if (al != direction) {
-                scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
+                scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
                 return;
             }
         }
         rct_drawpixelinfo* dpi = session->Unk140E9A8;
         if (dpi->zoom_level > 1) {
-            scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
+            scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
             return;
         }
         // 6B8331:
         // Draw sign text:
         set_format_arg(0, uint32, 0);
         set_format_arg(4, uint32, 0);
-        sint32 textColour = mapElement->properties.scenerymultiple.colour[1] & 0x1F;
+        sint32 textColour = tileElement->properties.scenerymultiple.colour[1] & 0x1F;
         if (dword_F4387C) {
             textColour = COLOUR_GREY;
         }
         textColour = (textColour << 19) | IMAGE_TYPE_REMAP;
-        uint32 bannerIndex = (mapElement->type & 0xC0) | ((mapElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) | ((mapElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
+        uint32 bannerIndex = (tileElement->type & 0xC0) | ((tileElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) | ((tileElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
         rct_banner *banner = &gBanners[bannerIndex];
         rct_string_id stringId = banner->string_idx;
         if (banner->flags & BANNER_FLAG_LINKED_TO_RIDE) {
@@ -326,18 +326,18 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
     }
     rct_drawpixelinfo* dpi = session->Unk140E9A8;
     if (dpi->zoom_level > 0) {
-        scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
+        scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
         return;
     }
-    uint8 al = ((mapElement->properties.surface.terrain >> 2) - 1) & 3;
+    uint8 al = ((tileElement->properties.surface.terrain >> 2) - 1) & 3;
     if (al != direction) {
-        scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
+        scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
         return;
     }
     // Draw scrolling text:
     set_format_arg(0, uint32, 0);
     set_format_arg(4, uint32, 0);
-    uint8 textColour = mapElement->properties.banner.unused & 0x1F;
+    uint8 textColour = tileElement->properties.banner.unused & 0x1F;
     if (dword_F4387C) {
         textColour = COLOUR_GREY;
     }
@@ -346,7 +346,7 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
     }
     // 6B809A:
     set_format_arg(7, uint8, textColour);
-    uint32 bannerIndex = (mapElement->type & 0xC0) | ((mapElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) | ((mapElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
+    uint32 bannerIndex = (tileElement->type & 0xC0) | ((tileElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) | ((tileElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
     uint16 scrollMode = entry->large_scenery.scrolling_mode + ((direction + 1) & 0x3);
     rct_banner *banner = &gBanners[bannerIndex];
     set_format_arg(0, rct_string_id, banner->string_idx);
@@ -369,5 +369,5 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
     uint16 scroll = (gCurrentTicks / 2) % string_width;
     sub_98199C(session, scrolling_text_setup(session, stringId, scroll, scrollMode), 0, 0, 1, 1, 21, height + 25, boxoffset.x, boxoffset.y, boxoffset.z, get_current_rotation());
 
-    scenery_multiple_paint_supports(session, direction, height, mapElement, dword_F4387C, tile);
+    scenery_multiple_paint_supports(session, direction, height, tileElement, dword_F4387C, tile);
 }
diff --git a/src/openrct2/paint/tile_element/surface.c b/src/openrct2/paint/tile_element/surface.c
index 3807d0324e..d3efef7ce1 100644
--- a/src/openrct2/paint/tile_element/surface.c
+++ b/src/openrct2/paint/tile_element/surface.c
@@ -339,9 +339,9 @@ struct tile_descriptor
     corner_height corner_heights;
 };
 
-static uint8 viewport_surface_paint_setup_get_relative_slope(rct_tile_element * mapElement, sint32 rotation)
+static uint8 viewport_surface_paint_setup_get_relative_slope(rct_tile_element * tileElement, sint32 rotation)
 {
-    uint8 slope = mapElement->properties.surface.slope;
+    uint8 slope = tileElement->properties.surface.slope;
 
     uint16 di = (slope & 0x0F) << rotation;
     uint8 ebx = slope & 0x10;
@@ -988,18 +988,18 @@ static void viewport_surface_draw_water_side_bottom(paint_session * session, enu
  * @param height (dx)
  * @param tile_element (esi)
  */
-void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element * mapElement)
+void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element * tileElement)
 {
     rct_drawpixelinfo * dpi = session->Unk140E9A8;
     session->InteractionType = VIEWPORT_INTERACTION_ITEM_TERRAIN;
     session->DidPassSurface = true;
-    session->SurfaceElement = mapElement;
+    session->SurfaceElement = tileElement;
 
     uint16 zoomLevel = dpi->zoom_level;
 
     const uint8 rotation = get_current_rotation();
-    uint32 terrain_type = tile_element_get_terrain(mapElement);
-    uint32 surfaceShape = viewport_surface_paint_setup_get_relative_slope(mapElement, rotation);
+    uint32 terrain_type = tile_element_get_terrain(tileElement);
+    uint32 surfaceShape = viewport_surface_paint_setup_get_relative_slope(tileElement, rotation);
 
     LocationXY16 base = {
         .x = session->SpritePosition.x,
@@ -1008,7 +1008,7 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
 
     corner_height ch = corner_heights[surfaceShape];
     tile_descriptor selfDescriptor = {
-        .tile_element = mapElement,
+        .tile_element = tileElement,
         .slope = surfaceShape,
         .terrain = terrain_type,
         .corner_heights = {
@@ -1075,11 +1075,11 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
         bool showGridlines = (gCurrentViewportFlags & VIEWPORT_FLAG_GRIDLINES);
 
         sint32 branch = -1;
-        if ((mapElement->properties.surface.terrain & 0xE0) == 0) {
-            if (tile_element_get_direction(mapElement) == 0) {
+        if ((tileElement->properties.surface.terrain & 0xE0) == 0) {
+            if (tile_element_get_direction(tileElement) == 0) {
                 if (zoomLevel == 0) {
                     if ((gCurrentViewportFlags & (VIEWPORT_FLAG_HIDE_BASE | VIEWPORT_FLAG_UNDERGROUND_INSIDE)) == 0) {
-                        branch = mapElement->properties.surface.grass_length & 0x7;
+                        branch = tileElement->properties.surface.grass_length & 0x7;
                     }
                 }
             }
@@ -1189,10 +1189,10 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
 
     if (gCurrentViewportFlags & VIEWPORT_FLAG_LAND_OWNERSHIP) {
         // loc_660E9A:
-        if (mapElement->properties.surface.ownership & OWNERSHIP_OWNED) {
+        if (tileElement->properties.surface.ownership & OWNERSHIP_OWNED) {
             assert(surfaceShape < countof(byte_97B444));
             paint_attach_to_previous_ps(session, SPR_TERRAIN_SELECTION_SQUARE + byte_97B444[surfaceShape], 0, 0);
-        } else if (mapElement->properties.surface.ownership & OWNERSHIP_AVAILABLE) {
+        } else if (tileElement->properties.surface.ownership & OWNERSHIP_AVAILABLE) {
             LocationXY16 pos = session->MapPosition;
             paint_struct * backup = session->UnkF1AD28;
             sint32 height2 = (tile_element_height(pos.x + 16, pos.y + 16) & 0xFFFF) + 3;
@@ -1202,11 +1202,11 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
     }
 
     if (gCurrentViewportFlags & VIEWPORT_FLAG_CONSTRUCTION_RIGHTS
-        && !(mapElement->properties.surface.ownership & OWNERSHIP_OWNED)) {
-        if (mapElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) {
+        && !(tileElement->properties.surface.ownership & OWNERSHIP_OWNED)) {
+        if (tileElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) {
             assert(surfaceShape < countof(byte_97B444));
             paint_attach_to_previous_ps(session, SPR_TERRAIN_SELECTION_DOTTED + byte_97B444[surfaceShape], 0, 0);
-        } else if (mapElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_AVAILABLE) {
+        } else if (tileElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_AVAILABLE) {
             paint_struct * backup = session->UnkF1AD28;
             LocationXY16 pos = session->MapPosition;
             sint32 height2 = tile_element_height(pos.x + 16, pos.y + 16) & 0xFFFF;
@@ -1254,9 +1254,9 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
                 sint32 local_surfaceShape = surfaceShape;
                 sint32 local_height = height;
                 // Water tool
-                if (map_get_water_height(mapElement) > 0)
+                if (map_get_water_height(tileElement) > 0)
                 {
-                    sint32 waterHeight = map_get_water_height(mapElement) * 16;
+                    sint32 waterHeight = map_get_water_height(tileElement) * 16;
                     if (waterHeight > height) {
                         local_height += 16;
 
@@ -1330,8 +1330,8 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
 
     if (!(gCurrentViewportFlags & VIEWPORT_FLAG_HIDE_VERTICAL)) {
         // loc_66122C:
-        uint8 al_edgeStyle = mapElement->properties.surface.slope & 0xE0;
-        uint8 di_type = mapElement->type & 0x80;
+        uint8 al_edgeStyle = tileElement->properties.surface.slope & 0xE0;
+        uint8 di_type = tileElement->type & 0x80;
 
         uint32 eax = al_edgeStyle + di_type * 2;
         if (eax != 32 && eax != 0 && eax != 96 && eax != 64) {
@@ -1353,13 +1353,13 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
         memcpy(session->RightTunnels, backupRightTunnels, sizeof(tunnel_entry) * TUNNEL_MAX_COUNT);
     }
 
-    if (map_get_water_height(mapElement) > 0)
+    if (map_get_water_height(tileElement) > 0)
     {
         // loc_6615A9: (water height)
         session->InteractionType = VIEWPORT_INTERACTION_ITEM_WATER;
 
         uint16 localHeight = height + 16;
-        uint16 waterHeight = map_get_water_height(mapElement) * 16;
+        uint16 waterHeight = map_get_water_height(tileElement) * 16;
 
         if (!gTrackDesignSaveMode) {
             session->Unk141E9DC = waterHeight;
@@ -1375,8 +1375,8 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
             paint_attach_to_previous_ps(session, SPR_WATER_OVERLAY + image_offset, 0, 0);
 
             // This wasn't in the original, but the code depended on globals that were only set in a different conditional
-            uint8 al_edgeStyle = mapElement->properties.surface.slope & 0xE0;
-            uint8 di_type = mapElement->type & 0x80;
+            uint8 al_edgeStyle = tileElement->properties.surface.slope & 0xE0;
+            uint8 di_type = tileElement->type & 0x80;
 
             uint32 eax = al_edgeStyle + di_type * 2;
             assert(eax % 32 == 0);
@@ -1389,14 +1389,14 @@ void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_
         }
     }
 
-    if ((mapElement->properties.surface.ownership & 0x0F) &&
+    if ((tileElement->properties.surface.ownership & 0x0F) &&
         !gTrackDesignSaveMode
     ) {
         // Owned land boundary fences
         session->InteractionType = VIEWPORT_INTERACTION_ITEM_PARK;
 
         registers regs = { 0 };
-        regs.al = mapElement->properties.surface.ownership & 0x0F;
+        regs.al = tileElement->properties.surface.ownership & 0x0F;
         regs.ax = regs.ax << rotation;
         regs.ah = regs.al >> 4;
 
diff --git a/src/openrct2/paint/tile_element/tile_element.h b/src/openrct2/paint/tile_element/tile_element.h
index 81661a43f4..12fc709dbf 100644
--- a/src/openrct2/paint/tile_element/tile_element.h
+++ b/src/openrct2/paint/tile_element/tile_element.h
@@ -104,12 +104,12 @@ void tile_element_paint_setup(paint_session * session, sint32 x, sint32 y);
 
 void entrance_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tile_element);
 void banner_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tile_element);
-void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement);
-void path_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement);
-void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* mapElement);
-void fence_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* mapElement);
-void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement);
-void track_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *mapElement);
+void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement);
+void path_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement);
+void scenery_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tileElement);
+void fence_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element* tileElement);
+void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement);
+void track_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *tileElement);
 
 #ifdef __cplusplus
 }
diff --git a/src/openrct2/peep/Peep.cpp b/src/openrct2/peep/Peep.cpp
index 8961f321bd..07d3de2f2b 100644
--- a/src/openrct2/peep/Peep.cpp
+++ b/src/openrct2/peep/Peep.cpp
@@ -602,25 +602,25 @@ static uint8 peep_assess_surroundings(sint16 centre_x, sint16 centre_y, sint16 c
     {
         for (sint16 y = initial_y; y < final_y; y += 32)
         {
-            rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
+            rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
 
             do
             {
                 Ride *              ride;
                 rct_scenery_entry * scenery;
 
-                switch (tile_element_get_type(mapElement))
+                switch (tile_element_get_type(tileElement))
                 {
                 case TILE_ELEMENT_TYPE_PATH:
-                    if (!footpath_element_has_path_scenery(mapElement))
+                    if (!footpath_element_has_path_scenery(tileElement))
                         break;
 
-                    scenery = get_footpath_item_entry(footpath_element_get_path_scenery_index(mapElement));
+                    scenery = get_footpath_item_entry(footpath_element_get_path_scenery_index(tileElement));
                     if (scenery == NULL)
                     {
                         return PEEP_THOUGHT_TYPE_NONE;
                     }
-                    if (footpath_element_path_scenery_is_ghost(mapElement))
+                    if (footpath_element_path_scenery_is_ghost(tileElement))
                         break;
 
                     if (scenery->path_bit.flags & (PATH_BIT_FLAG_JUMPING_FOUNTAIN_WATER | PATH_BIT_FLAG_JUMPING_FOUNTAIN_SNOW))
@@ -628,7 +628,7 @@ static uint8 peep_assess_surroundings(sint16 centre_x, sint16 centre_y, sint16 c
                         num_fountains++;
                         break;
                     }
-                    if (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+                    if (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
                     {
                         num_rubbish++;
                     }
@@ -638,7 +638,7 @@ static uint8 peep_assess_surroundings(sint16 centre_x, sint16 centre_y, sint16 c
                     num_scenery++;
                     break;
                 case TILE_ELEMENT_TYPE_TRACK:
-                    ride = get_ride(mapElement->properties.track.ride_index);
+                    ride = get_ride(tileElement->properties.track.ride_index);
                     if (ride->lifecycle_flags & RIDE_LIFECYCLE_MUSIC && ride->status != RIDE_STATUS_CLOSED &&
                         !(ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED)))
                     {
@@ -663,7 +663,7 @@ static uint8 peep_assess_surroundings(sint16 centre_x, sint16 centre_y, sint16 c
                     }
                     break;
                 }
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
         }
     }
 
@@ -1222,19 +1222,19 @@ static void sub_68F41A(rct_peep * peep, sint32 index)
             {
                 /* Peep happiness is affected once the peep has been waiting
                  * too long in a queue. */
-                rct_tile_element * mapElement = map_get_first_element_at(peep->next_x / 32, peep->next_y / 32);
+                rct_tile_element * tileElement = map_get_first_element_at(peep->next_x / 32, peep->next_y / 32);
                 uint8             found      = 0;
                 do
                 {
-                    if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
                         continue;
-                    if (mapElement->base_height != peep->next_z)
+                    if (tileElement->base_height != peep->next_z)
                         continue;
 
                     // Check if the footpath has a queue line TV monitor on it
-                    if (footpath_element_has_path_scenery(mapElement) && !footpath_element_path_scenery_is_ghost(mapElement))
+                    if (footpath_element_has_path_scenery(tileElement) && !footpath_element_path_scenery_is_ghost(tileElement))
                     {
-                        uint8               pathSceneryIndex = footpath_element_get_path_scenery_index(mapElement);
+                        uint8               pathSceneryIndex = footpath_element_get_path_scenery_index(tileElement);
                         rct_scenery_entry * sceneryEntry     = get_footpath_item_entry(pathSceneryIndex);
                         if (sceneryEntry->path_bit.flags & PATH_BIT_FLAG_IS_QUEUE_SCREEN)
                         {
@@ -1242,7 +1242,7 @@ static void sub_68F41A(rct_peep * peep, sint32 index)
                         }
                     }
                     break;
-                } while (!tile_element_is_last_for_tile(mapElement++));
+                } while (!tile_element_is_last_for_tile(tileElement++));
 
                 if (found)
                 {
@@ -2050,14 +2050,14 @@ bool peep_pickup_place(rct_peep * peep, sint32 x, sint32 y, sint32 z, bool apply
     if (!peep)
         return false;
 
-    rct_tile_element * mapElement = map_get_path_element_at(x / 32, y / 32, z);
+    rct_tile_element * tileElement = map_get_path_element_at(x / 32, y / 32, z);
 
-    if (!mapElement)
+    if (!tileElement)
     {
-        mapElement = map_get_surface_element_at(x / 32, y / 32);
+        tileElement = map_get_surface_element_at(x / 32, y / 32);
     }
 
-    if (!mapElement)
+    if (!tileElement)
         return false;
 
     sint32 dest_x = x & 0xFFE0;
@@ -2071,7 +2071,7 @@ bool peep_pickup_place(rct_peep * peep, sint32 x, sint32 y, sint32 z, bool apply
     sint32 tile_y = dest_y & 0xFFE0;
     sint32 tile_x = dest_x & 0xFFE0;
 
-    sint32 dest_z = mapElement->base_height * 8 + 16;
+    sint32 dest_z = tileElement->base_height * 8 + 16;
 
     if (!map_is_location_owned(tile_x, tile_y, dest_z))
     {
@@ -4232,15 +4232,15 @@ static void peep_update_ride_sub_state_17(rct_peep * peep)
     sint16 z = ride->station_heights[0];
 
     // Find the station track element
-    rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK && z == mapElement->base_height)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK && z == tileElement->base_height)
             break;
 
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
-    uint16 maze_entry  = mapElement->properties.track.maze_entry;
+    uint16 maze_entry  = tileElement->properties.track.maze_entry;
     uint16 open_hedges = 0;
     uint8  var_37      = peep->var_37;
     // var_37 is 3, 7, 11 or 15
@@ -4288,25 +4288,25 @@ static void peep_update_ride_sub_state_17(rct_peep * peep)
 
     uint8 type = 0;
 
-    mapElement = map_get_first_element_at(x / 32, y / 32);
+    tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (z != mapElement->base_height)
+        if (z != tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
         {
             type = 1;
             break;
         }
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE &&
-            mapElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE &&
+            tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT)
         {
             type = 2;
             break;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     switch (type)
     {
@@ -4391,14 +4391,14 @@ static void peep_update_ride_sub_state_18(rct_peep * peep)
     y = peep->y & 0xFFE0;
 
     // Find the station track element
-    rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        sint16 z = map_height_from_slope(peep->x, peep->y, mapElement->properties.path.type);
-        z += mapElement->base_height * 8;
+        sint16 z = map_height_from_slope(peep->x, peep->y, tileElement->properties.path.type);
+        z += tileElement->base_height * 8;
 
         sint16 z_diff = peep->z - z;
         if (z_diff > 0 || z_diff < -16)
@@ -4407,7 +4407,7 @@ static void peep_update_ride_sub_state_18(rct_peep * peep)
         sprite_move(peep->x, peep->y, z, (rct_sprite *)peep);
         invalidate_sprite_2((rct_sprite *)peep);
         return;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 }
 
 /**
@@ -4908,14 +4908,14 @@ static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep * peep, Ride
         uint16 stationX = stationPosition.x * 32;
         uint16 stationY = stationPosition.y * 32;
 
-        rct_tile_element * mapElement = map_get_track_element_at(stationX, stationY, stationZ);
-        if (mapElement == NULL)
+        rct_tile_element * tileElement = map_get_track_element_at(stationX, stationY, stationZ);
+        if (tileElement == NULL)
         {
             log_error("Couldn't find tile_element");
             return false;
         }
 
-        sint32       direction = tile_element_get_direction(mapElement);
+        sint32       direction = tile_element_get_direction(tileElement);
         LocationXY16 offset    = _992A3C[direction];
 
         stationX += 16 + offset.x;
@@ -8959,21 +8959,21 @@ static sint32 peep_interact_with_entrance(rct_peep * peep, sint16 x, sint16 y, r
         sint16 next_y = (y & 0xFFE0) + TileDirectionDelta[entranceDirection].y;
 
         uint8             found          = 0;
-        rct_tile_element * nextMapElement = map_get_first_element_at(next_x / 32, next_y / 32);
+        rct_tile_element * nextTileElement = map_get_first_element_at(next_x / 32, next_y / 32);
         do
         {
-            if (tile_element_get_type(nextMapElement) != TILE_ELEMENT_TYPE_PATH)
+            if (tile_element_get_type(nextTileElement) != TILE_ELEMENT_TYPE_PATH)
                 continue;
 
-            if (nextMapElement->type & 1)
+            if (nextTileElement->type & 1)
                 continue;
 
-            if (footpath_element_is_sloped(nextMapElement))
+            if (footpath_element_is_sloped(nextTileElement))
             {
-                uint8 slopeDirection = footpath_element_get_slope_direction(nextMapElement);
+                uint8 slopeDirection = footpath_element_get_slope_direction(nextTileElement);
                 if (slopeDirection == entranceDirection)
                 {
-                    if (z != nextMapElement->base_height)
+                    if (z != nextTileElement->base_height)
                     {
                         continue;
                     }
@@ -8984,21 +8984,21 @@ static sint32 peep_interact_with_entrance(rct_peep * peep, sint16 x, sint16 y, r
                 if ((slopeDirection ^ (1 << 1)) != entranceDirection)
                     continue;
 
-                if (z - 2 != nextMapElement->base_height)
+                if (z - 2 != nextTileElement->base_height)
                     continue;
                 found = 1;
                 break;
             }
             else
             {
-                if (z != nextMapElement->base_height)
+                if (z != nextTileElement->base_height)
                 {
                     continue;
                 }
                 found = 1;
                 break;
             }
-        } while (!tile_element_is_last_for_tile(nextMapElement++));
+        } while (!tile_element_is_last_for_tile(nextTileElement++));
 
         if (!found)
         {
@@ -9541,11 +9541,11 @@ static rct_tile_element * get_banner_on_path(rct_tile_element * path_element)
     return NULL;
 }
 
-static sint32 banner_clear_path_edges(rct_tile_element * mapElement, sint32 edges)
+static sint32 banner_clear_path_edges(rct_tile_element * tileElement, sint32 edges)
 {
     if (_peepPathFindIsStaff)
         return edges;
-    rct_tile_element * bannerElement = get_banner_on_path(mapElement);
+    rct_tile_element * bannerElement = get_banner_on_path(tileElement);
     if (bannerElement != NULL)
     {
         do
@@ -9559,19 +9559,19 @@ static sint32 banner_clear_path_edges(rct_tile_element * mapElement, sint32 edge
 /**
  * Gets the connected edges of a path that are permitted (i.e. no 'no entry' signs)
  */
-static sint32 path_get_permitted_edges(rct_tile_element * mapElement)
+static sint32 path_get_permitted_edges(rct_tile_element * tileElement)
 {
-    return banner_clear_path_edges(mapElement, mapElement->properties.path.edges) & 0x0F;
+    return banner_clear_path_edges(tileElement, tileElement->properties.path.edges) & 0x0F;
 }
 
-bool is_valid_path_z_and_direction(rct_tile_element * mapElement, sint32 currentZ, sint32 currentDirection)
+bool is_valid_path_z_and_direction(rct_tile_element * tileElement, sint32 currentZ, sint32 currentDirection)
 {
-    if (footpath_element_is_sloped(mapElement))
+    if (footpath_element_is_sloped(tileElement))
     {
-        sint32 slopeDirection = footpath_element_get_slope_direction(mapElement);
+        sint32 slopeDirection = footpath_element_get_slope_direction(tileElement);
         if (slopeDirection == currentDirection)
         {
-            if (currentZ != mapElement->base_height)
+            if (currentZ != tileElement->base_height)
                 return false;
         }
         else
@@ -9579,13 +9579,13 @@ bool is_valid_path_z_and_direction(rct_tile_element * mapElement, sint32 current
             slopeDirection ^= 2;
             if (slopeDirection != currentDirection)
                 return false;
-            if (currentZ != mapElement->base_height + 2)
+            if (currentZ != tileElement->base_height + 2)
                 return false;
         }
     }
     else
     {
-        if (currentZ != mapElement->base_height)
+        if (currentZ != tileElement->base_height)
             return false;
     }
     return true;
@@ -9602,16 +9602,16 @@ bool is_valid_path_z_and_direction(rct_tile_element * mapElement, sint32 current
  *  rct2: 0x00694BAE
  *
  * Returns the type of the next footpath tile a peep can get to from x,y,z /
- * inputMapElement in the given direction.
+ * inputTileElement in the given direction.
  */
-static uint8 footpath_element_next_in_direction(sint16 x, sint16 y, sint16 z, rct_tile_element * mapElement,
+static uint8 footpath_element_next_in_direction(sint16 x, sint16 y, sint16 z, rct_tile_element * tileElement,
                                                 uint8 chosenDirection)
 {
-    rct_tile_element * nextMapElement;
+    rct_tile_element * nextTileElement;
 
-    if (footpath_element_is_sloped(mapElement))
+    if (footpath_element_is_sloped(tileElement))
     {
-        if (footpath_element_get_slope_direction(mapElement) == chosenDirection)
+        if (footpath_element_get_slope_direction(tileElement) == chosenDirection)
         {
             z += 2;
         }
@@ -9619,23 +9619,23 @@ static uint8 footpath_element_next_in_direction(sint16 x, sint16 y, sint16 z, rc
 
     x += TileDirectionDelta[chosenDirection].x;
     y += TileDirectionDelta[chosenDirection].y;
-    nextMapElement = map_get_first_element_at(x / 32, y / 32);
+    nextTileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (nextMapElement->flags & TILE_ELEMENT_FLAG_GHOST)
+        if (nextTileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
-        if (tile_element_get_type(nextMapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(nextTileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
-        if (!is_valid_path_z_and_direction(nextMapElement, z, chosenDirection))
+        if (!is_valid_path_z_and_direction(nextTileElement, z, chosenDirection))
             continue;
-        if (footpath_element_is_wide(nextMapElement))
+        if (footpath_element_is_wide(nextTileElement))
             return PATH_SEARCH_WIDE;
         // Only queue tiles that are connected to a ride are returned as ride queues.
-        if (footpath_element_is_queue(nextMapElement) && nextMapElement->properties.path.ride_index != 0xFF)
+        if (footpath_element_is_queue(nextTileElement) && nextTileElement->properties.path.ride_index != 0xFF)
             return PATH_SEARCH_RIDE_QUEUE;
 
         return PATH_SEARCH_OTHER;
-    } while (!tile_element_is_last_for_tile(nextMapElement++));
+    } while (!tile_element_is_last_for_tile(nextTileElement++));
 
     return PATH_SEARCH_FAILED;
 }
@@ -9658,10 +9658,10 @@ static uint8 footpath_element_next_in_direction(sint16 x, sint16 y, sint16 z, rc
  *
  * This is the recursive portion of footpath_element_destination_in_direction().
  */
-static uint8 footpath_element_dest_in_dir(sint16 x, sint16 y, sint16 z, rct_tile_element * inputMapElement,
+static uint8 footpath_element_dest_in_dir(sint16 x, sint16 y, sint16 z, rct_tile_element * inputTileElement,
                                           uint8 chosenDirection, uint8 * outRideIndex, sint32 level)
 {
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
     sint32            direction;
 
     if (level > 25)
@@ -9669,23 +9669,23 @@ static uint8 footpath_element_dest_in_dir(sint16 x, sint16 y, sint16 z, rct_tile
 
     x += TileDirectionDelta[chosenDirection].x;
     y += TileDirectionDelta[chosenDirection].y;
-    mapElement = map_get_first_element_at(x / 32, y / 32);
-    if (mapElement == nullptr)
+    tileElement = map_get_first_element_at(x / 32, y / 32);
+    if (tileElement == nullptr)
     {
         return PATH_SEARCH_FAILED;
     }
     do
     {
-        if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
 
-        switch (tile_element_get_type(mapElement))
+        switch (tile_element_get_type(tileElement))
         {
         case TILE_ELEMENT_TYPE_TRACK:
         {
-            if (z != mapElement->base_height)
+            if (z != tileElement->base_height)
                 continue;
-            sint32 rideIndex = mapElement->properties.track.ride_index;
+            sint32 rideIndex = tileElement->properties.track.ride_index;
             Ride * ride      = get_ride(rideIndex);
             if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
             {
@@ -9695,23 +9695,23 @@ static uint8 footpath_element_dest_in_dir(sint16 x, sint16 y, sint16 z, rct_tile
         }
         break;
         case TILE_ELEMENT_TYPE_ENTRANCE:
-            if (z != mapElement->base_height)
+            if (z != tileElement->base_height)
                 continue;
-            switch (mapElement->properties.entrance.type)
+            switch (tileElement->properties.entrance.type)
             {
             case ENTRANCE_TYPE_RIDE_ENTRANCE:
-                direction = tile_element_get_direction(mapElement);
+                direction = tile_element_get_direction(tileElement);
                 if (direction == chosenDirection)
                 {
-                    *outRideIndex = mapElement->properties.entrance.ride_index;
+                    *outRideIndex = tileElement->properties.entrance.ride_index;
                     return PATH_SEARCH_RIDE_ENTRANCE;
                 }
                 break;
             case ENTRANCE_TYPE_RIDE_EXIT:
-                direction = tile_element_get_direction(mapElement);
+                direction = tile_element_get_direction(tileElement);
                 if (direction == chosenDirection)
                 {
-                    *outRideIndex = mapElement->properties.entrance.ride_index;
+                    *outRideIndex = tileElement->properties.entrance.ride_index;
                     return PATH_SEARCH_RIDE_EXIT;
                 }
                 break;
@@ -9720,14 +9720,14 @@ static uint8 footpath_element_dest_in_dir(sint16 x, sint16 y, sint16 z, rct_tile
             }
             break;
         case TILE_ELEMENT_TYPE_PATH:
-            if (!is_valid_path_z_and_direction(mapElement, z, chosenDirection))
+            if (!is_valid_path_z_and_direction(tileElement, z, chosenDirection))
                 continue;
-            if (footpath_element_is_wide(mapElement))
+            if (footpath_element_is_wide(tileElement))
                 return PATH_SEARCH_WIDE;
 
-            uint8 edges = path_get_permitted_edges(mapElement);
+            uint8 edges = path_get_permitted_edges(tileElement);
             edges &= ~(1 << (chosenDirection ^ 2));
-            z = mapElement->base_height;
+            z = tileElement->base_height;
 
             for (direction = 0; direction < 4; direction++)
             {
@@ -9738,18 +9738,18 @@ static uint8 footpath_element_dest_in_dir(sint16 x, sint16 y, sint16 z, rct_tile
                 if (edges != 0)
                     return PATH_SEARCH_JUNCTION;
 
-                if (footpath_element_is_sloped(mapElement))
+                if (footpath_element_is_sloped(tileElement))
                 {
-                    if (footpath_element_get_slope_direction(mapElement) == direction)
+                    if (footpath_element_get_slope_direction(tileElement) == direction)
                     {
                         z += 2;
                     }
                 }
-                return footpath_element_dest_in_dir(x, y, z, mapElement, direction, outRideIndex, level + 1);
+                return footpath_element_dest_in_dir(x, y, z, tileElement, direction, outRideIndex, level + 1);
             }
             return PATH_SEARCH_DEAD_END;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return PATH_SEARCH_FAILED;
 }
@@ -9770,25 +9770,25 @@ static uint8 footpath_element_dest_in_dir(sint16 x, sint16 y, sint16 z, rct_tile
  *  rct2: 0x006949A4
  *
  * Returns the destination tile type a peep can get to from x,y,z /
- * inputMapElement in the given direction following single width paths only
+ * inputTileElement in the given direction following single width paths only
  * and stopping as soon as a path junction is encountered.
  * Note that a junction is a path with > 2 reachable neighbouring path tiles,
  * so wide paths have LOTS of junctions.
  * This is useful for finding out what is at the end of a short single
  * width path, for example that leads from a ride exit back to the main path.
  */
-static uint8 footpath_element_destination_in_direction(sint16 x, sint16 y, sint16 z, rct_tile_element * inputMapElement,
+static uint8 footpath_element_destination_in_direction(sint16 x, sint16 y, sint16 z, rct_tile_element * inputTileElement,
                                                        uint8 chosenDirection, uint8 * outRideIndex)
 {
-    if (footpath_element_is_sloped(inputMapElement))
+    if (footpath_element_is_sloped(inputTileElement))
     {
-        if (footpath_element_get_slope_direction(inputMapElement) == chosenDirection)
+        if (footpath_element_get_slope_direction(inputTileElement) == chosenDirection)
         {
             z += 2;
         }
     }
 
-    return footpath_element_dest_in_dir(x, y, z, inputMapElement, chosenDirection, outRideIndex, 0);
+    return footpath_element_dest_in_dir(x, y, z, inputTileElement, chosenDirection, outRideIndex, 0);
 }
 
 /**
@@ -9965,7 +9965,7 @@ static bool path_is_thin_junction(rct_tile_element * path, sint16 x, sint16 y, u
  *
  *  rct2: 0x0069A997
  */
-static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep * peep, rct_tile_element * currentMapElement,
+static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep * peep, rct_tile_element * currentTileElement,
                                            bool inPatrolArea, uint8 counter, uint16 * endScore, sint32 test_edge,
                                            uint8 * endJunctions, LocationXYZ8 junctionList[16], uint8 directionList[16],
                                            LocationXYZ8 * endXYZ, uint8 * endSteps)
@@ -9973,7 +9973,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
     uint8 searchResult = PATH_SEARCH_FAILED;
 
     bool currentElementIsWide =
-        (footpath_element_is_wide(currentMapElement) && !staff_can_ignore_wide_flag(peep, x, y, z, currentMapElement));
+        (footpath_element_is_wide(currentTileElement) && !staff_can_ignore_wide_flag(peep, x, y, z, currentTileElement));
 
     x += TileDirectionDelta[test_edge].x;
     y += TileDirectionDelta[test_edge].y;
@@ -10017,8 +10017,8 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
 
     /* Get the next map element of interest in the direction of test_edge. */
     bool              found      = false;
-    rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
-    if (mapElement == nullptr)
+    rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
+    if (tileElement == nullptr)
     {
         return;
     }
@@ -10027,19 +10027,19 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
         /* Look for all map elements that the peep could walk onto while
          * navigating to the goal, including the goal tile. */
 
-        if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
 
         uint8 rideIndex = 0xFF;
-        switch (tile_element_get_type(mapElement))
+        switch (tile_element_get_type(tileElement))
         {
         case TILE_ELEMENT_TYPE_TRACK:
         {
-            if (z != mapElement->base_height)
+            if (z != tileElement->base_height)
                 continue;
             /* For peeps heading for a shop, the goal is the shop
              * tile. */
-            rideIndex   = mapElement->properties.track.ride_index;
+            rideIndex   = tileElement->properties.track.ride_index;
             Ride * ride = get_ride(rideIndex);
             if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
             {
@@ -10053,11 +10053,11 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
             }
         }
         case TILE_ELEMENT_TYPE_ENTRANCE:
-            if (z != mapElement->base_height)
+            if (z != tileElement->base_height)
                 continue;
             sint32 direction;
             searchResult = PATH_SEARCH_OTHER;
-            switch (mapElement->properties.entrance.type)
+            switch (tileElement->properties.entrance.type)
             {
             case ENTRANCE_TYPE_RIDE_ENTRANCE:
                 /* For peeps heading for a ride without a queue, the
@@ -10065,12 +10065,12 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
                  * For mechanics heading for the ride entrance
                  * (in the case when the station has no exit),
                  * the goal is the ride entrance tile. */
-                direction = tile_element_get_direction(mapElement);
+                direction = tile_element_get_direction(tileElement);
                 if (direction == test_edge)
                 {
                     /* The rideIndex will be useful for
                      * adding transport rides later. */
-                    rideIndex    = mapElement->properties.entrance.ride_index;
+                    rideIndex    = tileElement->properties.entrance.ride_index;
                     searchResult = PATH_SEARCH_RIDE_ENTRANCE;
                     found        = true;
                     break;
@@ -10085,7 +10085,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
             case ENTRANCE_TYPE_RIDE_EXIT:
                 /* For mechanics heading for the ride exit, the
                  * goal is the ride exit tile. */
-                direction = tile_element_get_direction(mapElement);
+                direction = tile_element_get_direction(tileElement);
                 if (direction == test_edge)
                 {
                     searchResult = PATH_SEARCH_RIDE_EXIT;
@@ -10103,16 +10103,16 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
              * queue path.
              * Otherwise, peeps walk on path tiles to get to the goal. */
 
-            if (!is_valid_path_z_and_direction(mapElement, z, test_edge))
+            if (!is_valid_path_z_and_direction(tileElement, z, test_edge))
                 continue;
 
             // Path may be sloped, so set z to path base height.
-            z = mapElement->base_height;
+            z = tileElement->base_height;
 
-            if (footpath_element_is_wide(mapElement))
+            if (footpath_element_is_wide(tileElement))
             {
                 /* Check if staff can ignore this wide flag. */
-                if (!staff_can_ignore_wide_flag(peep, x, y, z, mapElement))
+                if (!staff_can_ignore_wide_flag(peep, x, y, z, tileElement))
                 {
                     searchResult = PATH_SEARCH_WIDE;
                     found        = true;
@@ -10122,7 +10122,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
 
             searchResult = PATH_SEARCH_THIN;
 
-            uint8 numEdges = bitcount(path_get_permitted_edges(mapElement));
+            uint8 numEdges = bitcount(path_get_permitted_edges(tileElement));
 
             if (numEdges < 2)
             {
@@ -10134,15 +10134,15 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
             }
             else
             { // numEdges == 2
-                if (footpath_element_is_queue(mapElement) &&
-                    mapElement->properties.path.ride_index != gPeepPathFindQueueRideIndex)
+                if (footpath_element_is_queue(tileElement) &&
+                    tileElement->properties.path.ride_index != gPeepPathFindQueueRideIndex)
                 {
-                    if (gPeepPathFindIgnoreForeignQueues && (mapElement->properties.path.ride_index != 0xFF))
+                    if (gPeepPathFindIgnoreForeignQueues && (tileElement->properties.path.ride_index != 0xFF))
                     {
                         // Path is a queue we aren't interested in
                         /* The rideIndex will be useful for
                          * adding transport rides later. */
-                        rideIndex    = mapElement->properties.path.ride_index;
+                        rideIndex    = tileElement->properties.path.ride_index;
                         searchResult = PATH_SEARCH_RIDE_QUEUE;
                     }
                 }
@@ -10163,10 +10163,10 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
         }
 #endif // defined(DEBUG_LEVEL_2) && DEBUG_LEVEL_2
 
-        /* At this point mapElement is of interest to the pathfinding. */
+        /* At this point tileElement is of interest to the pathfinding. */
 
-        /* Should we check that this mapElement is connected in the
-         * reverse direction? For some mapElement types this was
+        /* Should we check that this tileElement is connected in the
+         * reverse direction? For some tileElement types this was
          * already done above (e.g. ride entrances), but for others not.
          * Ignore for now. */
 
@@ -10279,7 +10279,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
         /* At this point the map element is a non-wide path.*/
 
         /* Get all the permitted_edges of the map element. */
-        uint8 edges = path_get_permitted_edges(mapElement);
+        uint8 edges = path_get_permitted_edges(tileElement);
 
 #if defined(DEBUG_LEVEL_2) && DEBUG_LEVEL_2
         if (gPathFindDebug)
@@ -10350,7 +10350,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
         {
             /* Check if this is a thin junction. And perform additional
              * necessary checks. */
-            thin_junction = path_is_thin_junction(mapElement, x, y, z);
+            thin_junction = path_is_thin_junction(tileElement, x, y, z);
 
             if (thin_junction)
             {
@@ -10476,7 +10476,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
             uint8 savedNumJunctions = _peepPathFindNumJunctions;
 
             uint8 height = z;
-            if (footpath_element_is_sloped(mapElement) && footpath_element_get_slope_direction(mapElement) == next_test_edge)
+            if (footpath_element_is_sloped(tileElement) && footpath_element_get_slope_direction(tileElement) == next_test_edge)
             {
                 height += 2;
             }
@@ -10505,7 +10505,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
                 _peepPathFindHistory[_peepPathFindNumJunctions + 1].direction = next_test_edge;
             }
 
-            peep_pathfind_heuristic_search(x, y, height, peep, mapElement, nextInPatrolArea, counter, endScore, next_test_edge,
+            peep_pathfind_heuristic_search(x, y, height, peep, tileElement, nextInPatrolArea, counter, endScore, next_test_edge,
                                            endJunctions, junctionList, directionList, endXYZ, endSteps);
             _peepPathFindNumJunctions = savedNumJunctions;
 
@@ -10518,7 +10518,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
 #endif // defined(DEBUG_LEVEL_2) && DEBUG_LEVEL_2
         } while ((next_test_edge = bitscanforward(edges)) != -1);
 
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     if (!found)
     {
@@ -11113,9 +11113,9 @@ static sint32 guest_path_find_park_entrance(rct_peep * peep, rct_tile_element *
 static void get_ride_queue_end(sint16 * x, sint16 * y, sint16 * z)
 {
     LocationXY16      result     = { 0, 0 };
-    rct_tile_element * mapElement = map_get_first_element_at(*x / 32, *y / 32);
+    rct_tile_element * tileElement = map_get_first_element_at(*x / 32, *y / 32);
 
-    if (mapElement == NULL)
+    if (tileElement == NULL)
     {
         return;
     }
@@ -11123,37 +11123,37 @@ static void get_ride_queue_end(sint16 * x, sint16 * y, sint16 * z)
     bool found = false;
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
 
-        if (*z != mapElement->base_height)
+        if (*z != tileElement->base_height)
             continue;
 
         found = true;
         break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     if (!found)
         return;
 
-    uint8             direction        = tile_element_get_direction_with_offset(mapElement, 2);
+    uint8             direction        = tile_element_get_direction_with_offset(tileElement, 2);
     rct_tile_element * lastPathElement  = NULL;
     rct_tile_element * firstPathElement = NULL;
 
-    sint16 baseZ = mapElement->base_height;
+    sint16 baseZ = tileElement->base_height;
     sint16 nextX = *x;
     sint16 nextY = *y;
     while (1)
     {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
         {
-            lastPathElement = mapElement;
+            lastPathElement = tileElement;
             result.x        = nextX;
             result.y        = nextY;
             // result.direction = direction;
-            if (footpath_element_is_sloped(mapElement))
+            if (footpath_element_is_sloped(tileElement))
             {
-                if (footpath_element_get_slope_direction(mapElement) == direction)
+                if (footpath_element_get_slope_direction(tileElement) == direction)
                 {
                     baseZ += 2;
                 }
@@ -11162,21 +11162,21 @@ static void get_ride_queue_end(sint16 * x, sint16 * y, sint16 * z)
         nextX += TileDirectionDelta[direction].x;
         nextY += TileDirectionDelta[direction].y;
 
-        mapElement = map_get_first_element_at(nextX / 32, nextY / 32);
+        tileElement = map_get_first_element_at(nextX / 32, nextY / 32);
         found      = false;
         do
         {
-            if (mapElement == firstPathElement)
+            if (tileElement == firstPathElement)
                 continue;
 
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
                 continue;
 
-            if (baseZ == mapElement->base_height)
+            if (baseZ == tileElement->base_height)
             {
-                if (footpath_element_is_sloped(mapElement))
+                if (footpath_element_is_sloped(tileElement))
                 {
-                    if (footpath_element_get_slope_direction(mapElement) != direction)
+                    if (footpath_element_get_slope_direction(tileElement) != direction)
                     {
                         break;
                     }
@@ -11185,45 +11185,45 @@ static void get_ride_queue_end(sint16 * x, sint16 * y, sint16 * z)
                 break;
             }
 
-            if (baseZ - 2 == mapElement->base_height)
+            if (baseZ - 2 == tileElement->base_height)
             {
-                if (!footpath_element_is_sloped(mapElement))
+                if (!footpath_element_is_sloped(tileElement))
                     break;
 
-                if (footpath_element_get_slope_direction(mapElement) != (direction ^ 2))
+                if (footpath_element_get_slope_direction(tileElement) != (direction ^ 2))
                     break;
 
                 baseZ -= 2;
                 found = true;
                 break;
             }
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
 
         if (found == false)
             break;
 
-        if (!footpath_element_is_queue(mapElement))
+        if (!footpath_element_is_queue(tileElement))
             break;
 
-        if (!(mapElement->properties.path.edges & (1 << (direction ^ (1 << 1)))))
+        if (!(tileElement->properties.path.edges & (1 << (direction ^ (1 << 1)))))
             break;
 
         if (firstPathElement == NULL)
-            firstPathElement = mapElement;
+            firstPathElement = tileElement;
 
         // More queue to go.
-        if (mapElement->properties.path.edges & (1 << (direction)))
+        if (tileElement->properties.path.edges & (1 << (direction)))
             continue;
 
         direction++;
         direction &= 3;
         // More queue to go.
-        if (mapElement->properties.path.edges & (1 << (direction)))
+        if (tileElement->properties.path.edges & (1 << (direction)))
             continue;
 
         direction ^= (1 << 1);
         // More queue to go.
-        if (mapElement->properties.path.edges & (1 << (direction)))
+        if (tileElement->properties.path.edges & (1 << (direction)))
             continue;
 
         break;
@@ -11232,16 +11232,16 @@ static void get_ride_queue_end(sint16 * x, sint16 * y, sint16 * z)
     if ((uint8)*z == 0xFF)
         return;
 
-    mapElement = lastPathElement;
-    if (mapElement == NULL)
+    tileElement = lastPathElement;
+    if (tileElement == NULL)
         return;
 
-    if (!footpath_element_is_queue(mapElement))
+    if (!footpath_element_is_queue(tileElement))
         return;
 
     *x = result.x;
     *y = result.y;
-    *z = mapElement->base_height;
+    *z = tileElement->base_height;
 }
 
 /**
@@ -11269,14 +11269,14 @@ static sint32 guest_path_finding(rct_peep * peep)
     y = peep->next_y;
     z = peep->next_z;
 
-    rct_tile_element * mapElement = map_get_path_element_at(x / 32, y / 32, z);
-    if (mapElement == NULL)
+    rct_tile_element * tileElement = map_get_path_element_at(x / 32, y / 32, z);
+    if (tileElement == NULL)
     {
         return 1;
     }
 
     _peepPathFindIsStaff = false;
-    uint8 edges          = path_get_permitted_edges(mapElement);
+    uint8 edges          = path_get_permitted_edges(tileElement);
 
     if (edges == 0)
     {
@@ -11285,7 +11285,7 @@ static sint32 guest_path_finding(rct_peep * peep)
 
     if (peep->outside_of_park == 0 && peep_heading_for_ride_or_park_exit(peep))
     {
-        /* If this mapElement is adjacent to any non-wide paths,
+        /* If this tileElement is adjacent to any non-wide paths,
          * remove all of the edges to wide paths. */
         uint8 adjustedEdges = edges;
         for (sint32 chosenDirection = 0; chosenDirection < 4; chosenDirection++)
@@ -11296,7 +11296,7 @@ static sint32 guest_path_finding(rct_peep * peep)
 
             /* If there is a wide path in that direction,
                 remove that edge and try another */
-            if (footpath_element_next_in_direction(peep->next_x, peep->next_y, peep->next_z, mapElement, chosenDirection) ==
+            if (footpath_element_next_in_direction(peep->next_x, peep->next_y, peep->next_z, tileElement, chosenDirection) ==
                 PATH_SEARCH_WIDE)
             {
                 adjustedEdges &= ~(1 << chosenDirection);
@@ -11353,9 +11353,9 @@ static sint32 guest_path_finding(rct_peep * peep)
         switch (peep->state)
         {
         case PEEP_STATE_ENTERING_PARK:
-            return guest_path_find_entering_park(peep, mapElement, edges);
+            return guest_path_find_entering_park(peep, tileElement, edges);
         case PEEP_STATE_LEAVING_PARK:
-            return guest_path_find_leaving_park(peep, mapElement, edges);
+            return guest_path_find_leaving_park(peep, tileElement, edges);
         default:
             return guest_path_find_aimless(peep, edges);
         }
@@ -11377,7 +11377,7 @@ static sint32 guest_path_finding(rct_peep * peep)
                 continue;
 
             uint8 rideIndex, pathSearchResult;
-            pathSearchResult = footpath_element_destination_in_direction(peep->next_x, peep->next_y, peep->next_z, mapElement,
+            pathSearchResult = footpath_element_destination_in_direction(peep->next_x, peep->next_y, peep->next_z, tileElement,
                                                                          chosenDirection, &rideIndex);
             switch (pathSearchResult)
             {
@@ -11421,7 +11421,7 @@ static sint32 guest_path_finding(rct_peep * peep)
         }
         pathfind_logging_disable();
 #endif // defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
-        return guest_path_find_park_entrance(peep, mapElement, edges);
+        return guest_path_find_park_entrance(peep, tileElement, edges);
     }
 
     if (peep->guest_heading_to_ride_id == 0xFF)
@@ -11616,35 +11616,35 @@ static sint32 peep_perform_next_action(rct_peep * peep)
         return peep_return_to_centre_of_tile(peep);
     }
 
-    rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     sint16            base_z     = Math::Max(0, (peep->z / 8) - 2);
     sint16            top_z      = (peep->z / 8) + 1;
 
     do
     {
-        if (base_z > mapElement->base_height)
+        if (base_z > tileElement->base_height)
             continue;
-        if (top_z < mapElement->base_height)
+        if (top_z < tileElement->base_height)
             continue;
-        if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
         {
-            if (peep_interact_with_path(peep, x, y, mapElement))
+            if (peep_interact_with_path(peep, x, y, tileElement))
                 return 1;
         }
-        else if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+        else if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
         {
-            if (peep_interact_with_shop(peep, x, y, mapElement))
+            if (peep_interact_with_shop(peep, x, y, tileElement))
                 return 1;
         }
-        else if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE)
+        else if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE)
         {
-            if (peep_interact_with_entrance(peep, x, y, mapElement))
+            if (peep_interact_with_entrance(peep, x, y, tileElement))
                 return 1;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     if (peep->type == PEEP_TYPE_STAFF || (peep->next_var_29 & 0x18))
     {
@@ -11666,17 +11666,17 @@ static sint32 peep_perform_next_action(rct_peep * peep)
                 return peep_return_to_centre_of_tile(peep);
             }
 
-            mapElement = map_get_surface_element_at(x / 32, y / 32);
-            if (mapElement == NULL)
+            tileElement = map_get_surface_element_at(x / 32, y / 32);
+            if (tileElement == NULL)
                 return peep_return_to_centre_of_tile(peep);
 
-            sint16 water_height = map_get_water_height(mapElement);
+            sint16 water_height = map_get_water_height(tileElement);
             if (water_height)
                 return peep_return_to_centre_of_tile(peep);
 
             peep->next_x      = x & 0xFFE0;
             peep->next_y      = y & 0xFFE0;
-            peep->next_z      = mapElement->base_height;
+            peep->next_z      = tileElement->base_height;
             peep->next_var_29 = 8;
 
             z = peep_get_height_on_slope(peep, x, y);
@@ -12581,15 +12581,15 @@ static void peep_easter_egg_peep_interactions(rct_peep * peep)
  *
  * @return (CF)
  */
-static bool peep_should_watch_ride(rct_tile_element * mapElement)
+static bool peep_should_watch_ride(rct_tile_element * tileElement)
 {
-    Ride * ride = get_ride(mapElement->properties.track.ride_index);
+    Ride * ride = get_ride(tileElement->properties.track.ride_index);
 
     // Ghosts are purely this-client-side and should not cause any interaction,
     // as that may lead to a desync.
     if (network_get_mode() != NETWORK_MODE_NONE)
     {
-        if (tile_element_is_ghost(mapElement))
+        if (tile_element_is_ghost(tileElement))
             return false;
     }
 
@@ -12648,34 +12648,34 @@ static bool peep_should_watch_ride(rct_tile_element * mapElement)
  */
 static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideToView, uint8 * rideSeatToView)
 {
-    rct_tile_element *mapElement, *surfaceElement;
+    rct_tile_element *tileElement, *surfaceElement;
 
     surfaceElement = map_get_surface_element_at(peep->next_x / 32, peep->next_y / 32);
 
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
             continue;
-        if (tile_element_get_direction(mapElement) != edge)
+        if (tile_element_get_direction(tileElement) != edge)
             continue;
-        auto wallEntry = get_wall_entry(mapElement->properties.wall.type);
+        auto wallEntry = get_wall_entry(tileElement->properties.wall.type);
         if (wallEntry == nullptr || wallEntry->wall.flags2 & WALL_SCENERY_2_FLAG4)
             continue;
-        if (peep->next_z + 4 <= mapElement->base_height)
+        if (peep->next_z + 4 <= tileElement->base_height)
             continue;
-        if (peep->next_z + 1 >= mapElement->clearance_height)
+        if (peep->next_z + 1 >= tileElement->clearance_height)
             continue;
 
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     uint16 x = peep->next_x + TileDirectionDelta[edge].x;
     uint16 y = peep->next_y + TileDirectionDelta[edge].y;
@@ -12686,67 +12686,67 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
 
     surfaceElement = map_get_surface_element_at(x / 32, y / 32);
 
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
             continue;
-        if (tile_element_get_direction_with_offset(mapElement, 2) != edge)
+        if (tile_element_get_direction_with_offset(tileElement, 2) != edge)
             continue;
-        auto wallEntry = get_wall_entry(mapElement->properties.wall.type);
+        auto wallEntry = get_wall_entry(tileElement->properties.wall.type);
         if (wallEntry == nullptr || wallEntry->wall.flags2 & WALL_SCENERY_2_FLAG4)
             continue;
         // TODO: Check whether this shouldn't be <=, as the other loops use. If so, also extract as loop A.
-        if (peep->next_z + 4 >= mapElement->base_height)
+        if (peep->next_z + 4 >= tileElement->base_height)
             continue;
-        if (peep->next_z + 1 >= mapElement->clearance_height)
+        if (peep->next_z + 1 >= tileElement->clearance_height)
             continue;
 
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     // TODO: Extract loop B
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
 
-        if (mapElement->clearance_height + 1 < peep->next_z)
+        if (tileElement->clearance_height + 1 < peep->next_z)
             continue;
-        if (peep->next_z + 6 < mapElement->base_height)
+        if (peep->next_z + 6 < tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
         {
-            if (peep_should_watch_ride(mapElement))
+            if (peep_should_watch_ride(tileElement))
             {
-                return loc_690FD0(peep, rideToView, rideSeatToView, mapElement);
+                return loc_690FD0(peep, rideToView, rideSeatToView, tileElement);
             }
         }
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
         {
-            if (!(get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF)->large_scenery.flags &
+            if (!(get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF)->large_scenery.flags &
                   LARGE_SCENERY_FLAG_PHOTOGENIC))
             {
                 continue;
             }
 
             *rideSeatToView = 0;
-            if (mapElement->clearance_height >= peep->next_z + 8)
+            if (tileElement->clearance_height >= peep->next_z + 8)
             {
                 *rideSeatToView = 0x02;
             }
@@ -12755,31 +12755,31 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
 
             return true;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     // TODO: Extract loop C
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (mapElement->clearance_height + 1 < peep->next_z)
+        if (tileElement->clearance_height + 1 < peep->next_z)
             continue;
-        if (peep->next_z + 6 < mapElement->base_height)
+        if (peep->next_z + 6 < tileElement->base_height)
             continue;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
             continue;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
         {
-            auto wallEntry = get_wall_entry(mapElement->properties.wall.type);
+            auto wallEntry = get_wall_entry(tileElement->properties.wall.type);
             if (wallEntry == nullptr || wallEntry->wall.flags2 & WALL_SCENERY_2_FLAG4)
             {
                 continue;
@@ -12787,7 +12787,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
         }
 
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     x += TileDirectionDelta[edge].x;
     y += TileDirectionDelta[edge].y;
@@ -12799,58 +12799,58 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
     surfaceElement = map_get_surface_element_at(x / 32, y / 32);
 
     // TODO: extract loop A
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
             continue;
-        if (tile_element_get_direction_with_offset(mapElement, 2) != edge)
+        if (tile_element_get_direction_with_offset(tileElement, 2) != edge)
             continue;
-        auto wallEntry = get_wall_entry(mapElement->properties.wall.type);
+        auto wallEntry = get_wall_entry(tileElement->properties.wall.type);
         if (wallEntry == nullptr || wallEntry->wall.flags2 & WALL_SCENERY_2_FLAG4)
             continue;
-        if (peep->next_z + 6 <= mapElement->base_height)
+        if (peep->next_z + 6 <= tileElement->base_height)
             continue;
-        if (peep->next_z >= mapElement->clearance_height)
+        if (peep->next_z >= tileElement->clearance_height)
             continue;
 
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     // TODO: Extract loop B
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (mapElement->clearance_height + 1 < peep->next_z)
+        if (tileElement->clearance_height + 1 < peep->next_z)
             continue;
-        if (peep->next_z + 8 < mapElement->base_height)
+        if (peep->next_z + 8 < tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
         {
-            if (peep_should_watch_ride(mapElement))
+            if (peep_should_watch_ride(tileElement))
             {
-                return loc_690FD0(peep, rideToView, rideSeatToView, mapElement);
+                return loc_690FD0(peep, rideToView, rideSeatToView, tileElement);
             }
         }
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
         {
-            auto sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
+            auto sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
             if (!(sceneryEntry == nullptr || sceneryEntry->large_scenery.flags &
                   LARGE_SCENERY_FLAG_PHOTOGENIC))
             {
@@ -12858,7 +12858,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             }
 
             *rideSeatToView = 0;
-            if (mapElement->clearance_height >= peep->next_z + 8)
+            if (tileElement->clearance_height >= peep->next_z + 8)
             {
                 *rideSeatToView = 0x02;
             }
@@ -12867,31 +12867,31 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
 
             return true;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     // TODO: Extract loop C
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (mapElement->clearance_height + 1 < peep->next_z)
+        if (tileElement->clearance_height + 1 < peep->next_z)
             continue;
-        if (peep->next_z + 8 < mapElement->base_height)
+        if (peep->next_z + 8 < tileElement->base_height)
             continue;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
             continue;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
         {
-            auto wallEntry = get_wall_entry(mapElement->properties.wall.type);
+            auto wallEntry = get_wall_entry(tileElement->properties.wall.type);
             if (wallEntry == nullptr || wallEntry->wall.flags2 & WALL_SCENERY_2_FLAG4)
             {
                 continue;
@@ -12899,7 +12899,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
         }
 
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     x += TileDirectionDelta[edge].x;
     y += TileDirectionDelta[edge].y;
@@ -12911,65 +12911,65 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
     surfaceElement = map_get_surface_element_at(x / 32, y / 32);
 
     // TODO: extract loop A
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
             continue;
-        if (tile_element_get_direction_with_offset(mapElement, 2) != edge)
+        if (tile_element_get_direction_with_offset(tileElement, 2) != edge)
             continue;
-        auto wallEntry = get_wall_entry(mapElement->properties.wall.type);
+        auto wallEntry = get_wall_entry(tileElement->properties.wall.type);
         if (wallEntry == nullptr || wallEntry->wall.flags2 & WALL_SCENERY_2_FLAG4)
             continue;
-        if (peep->next_z + 8 <= mapElement->base_height)
+        if (peep->next_z + 8 <= tileElement->base_height)
             continue;
-        if (peep->next_z >= mapElement->clearance_height)
+        if (peep->next_z >= tileElement->clearance_height)
             continue;
 
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     // TODO: Extract loop B
-    mapElement = surfaceElement;
+    tileElement = surfaceElement;
     do
     {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (mapElement->clearance_height + 1 < peep->next_z)
+        if (tileElement->clearance_height + 1 < peep->next_z)
             continue;
-        if (peep->next_z + 10 < mapElement->base_height)
+        if (peep->next_z + 10 < tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
         {
-            if (peep_should_watch_ride(mapElement))
+            if (peep_should_watch_ride(tileElement))
             {
-                return loc_690FD0(peep, rideToView, rideSeatToView, mapElement);
+                return loc_690FD0(peep, rideToView, rideSeatToView, tileElement);
             }
         }
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
         {
-            if (!(get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF)->large_scenery.flags &
+            if (!(get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF)->large_scenery.flags &
                   LARGE_SCENERY_FLAG_PHOTOGENIC))
             {
                 continue;
             }
 
             *rideSeatToView = 0;
-            if (mapElement->clearance_height >= peep->next_z + 8)
+            if (tileElement->clearance_height >= peep->next_z + 8)
             {
                 *rideSeatToView = 0x02;
             }
@@ -12978,7 +12978,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
 
             return true;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return false;
 }
@@ -13531,15 +13531,15 @@ static void peep_pick_ride_to_go_on(rct_peep * peep)
             {
                 if (x >= 0 && y >= 0 && x < (256 * 32) && y < (256 * 32))
                 {
-                    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
+                    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
                     do
                     {
-                        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+                        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                             continue;
 
-                        sint32 rideIndex = mapElement->properties.track.ride_index;
+                        sint32 rideIndex = tileElement->properties.track.ride_index;
                         _peepRideConsideration[rideIndex >> 5] |= (1u << (rideIndex & 0x1F));
-                    } while (!tile_element_is_last_for_tile(mapElement++));
+                    } while (!tile_element_is_last_for_tile(tileElement++));
                 }
             }
         }
@@ -13670,19 +13670,19 @@ static void peep_head_for_nearest_ride_type(rct_peep * peep, sint32 rideType)
             {
                 if (x >= 0 && y >= 0 && x < (256 * 32) && y < (256 * 32))
                 {
-                    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
+                    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
                     do
                     {
-                        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+                        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                             continue;
 
-                        sint32 rideIndex = mapElement->properties.track.ride_index;
+                        sint32 rideIndex = tileElement->properties.track.ride_index;
                         ride             = get_ride(rideIndex);
                         if (ride->type == rideType)
                         {
                             _peepRideConsideration[rideIndex >> 5] |= (1u << (rideIndex & 0x1F));
                         }
-                    } while (!tile_element_is_last_for_tile(mapElement++));
+                    } while (!tile_element_is_last_for_tile(tileElement++));
                 }
             }
         }
@@ -13802,19 +13802,19 @@ static void peep_head_for_nearest_ride_with_flags(rct_peep * peep, sint32 rideTy
             {
                 if (x >= 0 && y >= 0 && x < (256 * 32) && y < (256 * 32))
                 {
-                    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
+                    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
                     do
                     {
-                        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+                        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                             continue;
 
-                        sint32 rideIndex = mapElement->properties.track.ride_index;
+                        sint32 rideIndex = tileElement->properties.track.ride_index;
                         ride             = get_ride(rideIndex);
                         if (ride_type_has_flag(ride->type, rideTypeFlags))
                         {
                             _peepRideConsideration[rideIndex >> 5] |= (1u << (rideIndex & 0x1F));
                         }
-                    } while (!tile_element_is_last_for_tile(mapElement++));
+                    } while (!tile_element_is_last_for_tile(tileElement++));
                 }
             }
         }
diff --git a/src/openrct2/peep/Peep.h b/src/openrct2/peep/Peep.h
index 7766e40320..8407db26d0 100644
--- a/src/openrct2/peep/Peep.h
+++ b/src/openrct2/peep/Peep.h
@@ -801,7 +801,7 @@ void game_command_set_guest_name(sint32 * eax, sint32 * ebx, sint32 * ecx, sint3
 sint32 peep_pathfind_choose_direction(sint16 x, sint16 y, uint8 z, rct_peep * peep);
 void   peep_reset_pathfind_goal(rct_peep * peep);
 
-bool is_valid_path_z_and_direction(rct_tile_element * mapElement, sint32 currentZ, sint32 currentDirection);
+bool is_valid_path_z_and_direction(rct_tile_element * tileElement, sint32 currentZ, sint32 currentDirection);
 
 #if defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
 #define PATHFIND_DEBUG 0 // Set to 0 to disable pathfinding debugging;
diff --git a/src/openrct2/peep/Staff.cpp b/src/openrct2/peep/Staff.cpp
index 9455610cc8..331fb4ef89 100644
--- a/src/openrct2/peep/Staff.cpp
+++ b/src/openrct2/peep/Staff.cpp
@@ -954,34 +954,34 @@ static uint8 staff_handyman_direction_to_nearest_litter(rct_peep * peep)
 
     sint16 nextZ = ((peep->z + 8) & 0xFFF0) / 8;
 
-    rct_tile_element * mapElement = map_get_first_element_at(nextTile.x / 32, nextTile.y / 32);
+    rct_tile_element * tileElement = map_get_first_element_at(nextTile.x / 32, nextTile.y / 32);
 
     do
     {
-        if (mapElement->base_height != nextZ)
+        if (tileElement->base_height != nextZ)
             continue;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
-            tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
+            tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
         {
             return 0xFF;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     nextTile.x = (peep->x & 0xFFE0) + TileDirectionDelta[nextDirection].x;
     nextTile.y = (peep->y & 0xFFE0) + TileDirectionDelta[nextDirection].y;
 
-    mapElement = map_get_first_element_at(nextTile.x / 32, nextTile.y / 32);
+    tileElement = map_get_first_element_at(nextTile.x / 32, nextTile.y / 32);
 
     do
     {
-        if (mapElement->base_height != nextZ)
+        if (tileElement->base_height != nextZ)
             continue;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
-            tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
+            tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
         {
             return 0xFF;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return nextDirection;
 }
@@ -996,17 +996,17 @@ static uint8 staff_handyman_direction_to_uncut_grass(rct_peep * peep, uint8 vali
     if (!(peep->next_var_29 & 0x18))
     {
 
-        rct_tile_element * mapElement = map_get_surface_element_at(peep->next_x / 32, peep->next_y / 32);
+        rct_tile_element * tileElement = map_get_surface_element_at(peep->next_x / 32, peep->next_y / 32);
 
-        if (peep->next_z != mapElement->base_height)
+        if (peep->next_z != tileElement->base_height)
             return 0xFF;
 
         if (peep->next_var_29 & 0x4)
         {
-            if ((mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK) != byte_98D800[peep->next_var_29 & 0x3])
+            if ((tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK) != byte_98D800[peep->next_var_29 & 0x3])
                 return 0xFF;
         }
-        else if ((mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK) != 0)
+        else if ((tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK) != 0)
             return 0xFF;
     }
 
@@ -1026,15 +1026,15 @@ static uint8 staff_handyman_direction_to_uncut_grass(rct_peep * peep, uint8 vali
         if (chosenTile.x > 0x1FFF || chosenTile.y > 0x1FFF)
             continue;
 
-        rct_tile_element * mapElement = map_get_surface_element_at(chosenTile.x / 32, chosenTile.y / 32);
+        rct_tile_element * tileElement = map_get_surface_element_at(chosenTile.x / 32, chosenTile.y / 32);
 
-        if (tile_element_get_terrain(mapElement) != 0)
+        if (tile_element_get_terrain(tileElement) != 0)
             continue;
 
-        if (abs(mapElement->base_height - peep->next_z) > 2)
+        if (abs(tileElement->base_height - peep->next_z) > 2)
             continue;
 
-        if ((mapElement->properties.surface.grass_length & 0x7) < GRASS_LENGTH_CLEAR_1)
+        if ((tileElement->properties.surface.grass_length & 0x7) < GRASS_LENGTH_CLEAR_1)
             continue;
 
         return chosenDirection;
@@ -1100,12 +1100,12 @@ static sint32 staff_path_finding_handyman(rct_peep * peep)
         }
         else
         {
-            rct_tile_element * mapElement = map_get_path_element_at(peep->next_x / 32, peep->next_y / 32, peep->next_z);
+            rct_tile_element * tileElement = map_get_path_element_at(peep->next_x / 32, peep->next_y / 32, peep->next_z);
 
-            if (mapElement == NULL)
+            if (tileElement == NULL)
                 return 1;
 
-            uint8 pathDirections = (mapElement->properties.path.edges & validDirections) & 0xF;
+            uint8 pathDirections = (tileElement->properties.path.edges & validDirections) & 0xF;
             if (pathDirections == 0)
             {
                 direction = staff_handyman_direction_rand_surface(peep, validDirections);
@@ -1328,22 +1328,22 @@ static uint8 staff_mechanic_direction_path(rct_peep * peep, uint8 validDirection
 
         // Find the exit/entrance tile_element
         bool              entranceFound = false;
-        rct_tile_element * mapElement    = map_get_first_element_at(chosenTile.x / 32, chosenTile.y / 32);
+        rct_tile_element * tileElement    = map_get_first_element_at(chosenTile.x / 32, chosenTile.y / 32);
         do
         {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
 
-            if (mapElement->base_height != z)
+            if (tileElement->base_height != z)
                 continue;
 
-            if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE &&
-                mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT)
+            if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE &&
+                tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT)
                 continue;
 
             entranceFound = true;
             break;
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
 
         if (entranceFound == false)
         {
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index 4dc6bf5ab7..616a2eab92 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -215,7 +215,7 @@ public:
         ImportRides();
         ImportRideMeasurements();
         ImportSprites();
-        ImportMapElements();
+        ImportTileElements();
         ImportMapAnimations();
         ImportPeepSpawns();
         ImportFinance();
@@ -452,34 +452,34 @@ private:
     {
         size_t maxTiles = 128 * 128;
         size_t tileIndex = 0;
-        rct_tile_element * mapElement = _s4.tile_elements;
+        rct_tile_element * tileElement = _s4.tile_elements;
 
         while (tileIndex < maxTiles)
         {
-            switch (tile_element_get_type(mapElement)) {
+            switch (tile_element_get_type(tileElement)) {
             case TILE_ELEMENT_TYPE_PATH:
             {
-                uint8 pathColour = tile_element_get_direction(mapElement);
-                uint8 pathType = (mapElement->properties.path.type & 0xF0) >> 4;
+                uint8 pathColour = tile_element_get_direction(tileElement);
+                uint8 pathType = (tileElement->properties.path.type & 0xF0) >> 4;
 
                 pathType = (pathType << 2) | pathColour;
-                uint8 pathAdditionsType = mapElement->properties.path.additions & 0x0F;
+                uint8 pathAdditionsType = tileElement->properties.path.additions & 0x0F;
 
                 AddEntryForPath(pathType);
                 AddEntryForPathAddition(pathAdditionsType);
                 break;
             }
             case TILE_ELEMENT_TYPE_SCENERY:
-                AddEntryForSmallScenery(mapElement->properties.scenery.type);
+                AddEntryForSmallScenery(tileElement->properties.scenery.type);
                 break;
             case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
-                AddEntryForLargeScenery(mapElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
+                AddEntryForLargeScenery(tileElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
                 break;
             case TILE_ELEMENT_TYPE_WALL:
             {
-                uint8  var_05 = mapElement->properties.wall.colour_3;
-                uint16 var_06 = mapElement->properties.wall.colour_1 |
-                               (mapElement->properties.wall.animation << 8);
+                uint8  var_05 = tileElement->properties.wall.colour_3;
+                uint16 var_06 = tileElement->properties.wall.colour_1 |
+                               (tileElement->properties.wall.animation << 8);
 
                 for (sint32 edge = 0; edge < 4; edge++)
                 {
@@ -495,7 +495,7 @@ private:
             }
             }
 
-            if (tile_element_is_last_for_tile(mapElement++))
+            if (tile_element_is_last_for_tile(tileElement++))
             {
                 tileIndex++;
             }
@@ -1869,18 +1869,18 @@ private:
         }
     }
 
-    void ImportMapElements()
+    void ImportTileElements()
     {
-        Memory::Copy(gMapElements, _s4.tile_elements, RCT1_MAX_TILE_ELEMENTS * sizeof(rct_tile_element));
+        Memory::Copy(gTileElements, _s4.tile_elements, RCT1_MAX_TILE_ELEMENTS * sizeof(rct_tile_element));
         ClearExtraTileEntries();
         FixSceneryColours();
-        FixMapElementZ();
+        FixTileElementZ();
         FixPaths();
         FixWalls();
         FixBanners();
         FixTerrain();
         FixEntrancePositions();
-        FixMapElementEntryTypes();
+        FixTileElementEntryTypes();
     }
 
     void ImportResearch()
@@ -2217,17 +2217,17 @@ private:
     void ClearExtraTileEntries()
     {
         // Reset the map tile pointers
-        Memory::Set(gMapElementTilePointers, 0, sizeof(rct_tile_element*) * MAX_TILE_TILE_ELEMENT_POINTERS);
+        Memory::Set(gTileElementTilePointers, 0, sizeof(rct_tile_element*) * MAX_TILE_TILE_ELEMENT_POINTERS);
 
         // Get the first free map element
-        rct_tile_element * nextFreeMapElement = gMapElements;
+        rct_tile_element * nextFreeTileElement = gTileElements;
         for (size_t i = 0; i < RCT1_MAX_MAP_SIZE * RCT1_MAX_MAP_SIZE; i++)
         {
-            while (!tile_element_is_last_for_tile(nextFreeMapElement++));
+            while (!tile_element_is_last_for_tile(nextFreeTileElement++));
         }
 
-        rct_tile_element * mapElement = gMapElements;
-        rct_tile_element * * tilePointer = gMapElementTilePointers;
+        rct_tile_element * tileElement = gTileElements;
+        rct_tile_element * * tilePointer = gTileElementTilePointers;
 
         // 128 rows of map data from RCT1 map
         for (sint32 x = 0; x < RCT1_MAX_MAP_SIZE; x++)
@@ -2235,160 +2235,160 @@ private:
             // Assign the first half of this row
             for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
             {
-                *tilePointer++ = mapElement;
-                while (!tile_element_is_last_for_tile(mapElement++));
+                *tilePointer++ = tileElement;
+                while (!tile_element_is_last_for_tile(tileElement++));
             }
 
             // Fill the rest of the row with blank tiles
             for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
             {
-                nextFreeMapElement->type = TILE_ELEMENT_TYPE_SURFACE;
-                nextFreeMapElement->flags = TILE_ELEMENT_FLAG_LAST_TILE;
-                nextFreeMapElement->base_height = 2;
-                nextFreeMapElement->clearance_height = 0;
-                nextFreeMapElement->properties.surface.slope = 0;
-                nextFreeMapElement->properties.surface.terrain = 0;
-                nextFreeMapElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
-                nextFreeMapElement->properties.surface.ownership = 0;
-                *tilePointer++ = nextFreeMapElement++;
+                nextFreeTileElement->type = TILE_ELEMENT_TYPE_SURFACE;
+                nextFreeTileElement->flags = TILE_ELEMENT_FLAG_LAST_TILE;
+                nextFreeTileElement->base_height = 2;
+                nextFreeTileElement->clearance_height = 0;
+                nextFreeTileElement->properties.surface.slope = 0;
+                nextFreeTileElement->properties.surface.terrain = 0;
+                nextFreeTileElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
+                nextFreeTileElement->properties.surface.ownership = 0;
+                *tilePointer++ = nextFreeTileElement++;
             }
         }
 
         // 128 extra rows left to fill with blank tiles
         for (sint32 y = 0; y < 128 * 256; y++)
         {
-            nextFreeMapElement->type = TILE_ELEMENT_TYPE_SURFACE;
-            nextFreeMapElement->flags = TILE_ELEMENT_FLAG_LAST_TILE;
-            nextFreeMapElement->base_height = 2;
-            nextFreeMapElement->clearance_height = 0;
-            nextFreeMapElement->properties.surface.slope = 0;
-            nextFreeMapElement->properties.surface.terrain = 0;
-            nextFreeMapElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
-            nextFreeMapElement->properties.surface.ownership = 0;
-            *tilePointer++ = nextFreeMapElement++;
+            nextFreeTileElement->type = TILE_ELEMENT_TYPE_SURFACE;
+            nextFreeTileElement->flags = TILE_ELEMENT_FLAG_LAST_TILE;
+            nextFreeTileElement->base_height = 2;
+            nextFreeTileElement->clearance_height = 0;
+            nextFreeTileElement->properties.surface.slope = 0;
+            nextFreeTileElement->properties.surface.terrain = 0;
+            nextFreeTileElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
+            nextFreeTileElement->properties.surface.ownership = 0;
+            *tilePointer++ = nextFreeTileElement++;
         }
 
-        gNextFreeMapElement = nextFreeMapElement;
+        gNextFreeTileElement = nextFreeTileElement;
     }
 
     void FixSceneryColours()
     {
         colour_t colour;
-        rct_tile_element * mapElement = gMapElements;
-        while (mapElement < gNextFreeMapElement)
+        rct_tile_element * tileElement = gTileElements;
+        while (tileElement < gNextFreeTileElement)
         {
-            if (mapElement->base_height != 255)
+            if (tileElement->base_height != 255)
             {
-                switch (tile_element_get_type(mapElement)) {
+                switch (tile_element_get_type(tileElement)) {
                 case TILE_ELEMENT_TYPE_SCENERY:
-                    colour = RCT1::GetColour(scenery_small_get_primary_colour(mapElement));
-                        scenery_small_set_primary_colour(mapElement, colour);
+                    colour = RCT1::GetColour(scenery_small_get_primary_colour(tileElement));
+                        scenery_small_set_primary_colour(tileElement, colour);
 
                     // Copied from [rct2: 0x006A2956]
-                    switch (mapElement->properties.scenery.type) {
+                    switch (tileElement->properties.scenery.type) {
                     case 157: // TGE1 (Geometric Sculpture)
                     case 162: // TGE2 (Geometric Sculpture)
                     case 168: // TGE3 (Geometric Sculpture)
                     case 170: // TGE4 (Geometric Sculpture)
                     case 171: // TGE5 (Geometric Sculpture)
-                        scenery_small_set_secondary_colour(mapElement, COLOUR_WHITE);
+                        scenery_small_set_secondary_colour(tileElement, COLOUR_WHITE);
                         break;
                     }
                     break;
                 case TILE_ELEMENT_TYPE_WALL:
-                    colour = ((mapElement->type & 0xC0) >> 3) |
-                             ((mapElement->properties.wall.type & 0xE0) >> 5);
+                    colour = ((tileElement->type & 0xC0) >> 3) |
+                             ((tileElement->properties.wall.type & 0xE0) >> 5);
                     colour = RCT1::GetColour(colour);
 
-                    mapElement->type &= 0x3F;
-                    mapElement->properties.wall.type &= 0x1F;
-                    mapElement->type |= (colour & 0x18) << 3;
-                    mapElement->properties.wall.type |= (colour & 7) << 5;
+                    tileElement->type &= 0x3F;
+                    tileElement->properties.wall.type &= 0x1F;
+                    tileElement->type |= (colour & 0x18) << 3;
+                    tileElement->properties.wall.type |= (colour & 7) << 5;
                     break;
                 case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
-                    colour = RCT1::GetColour(mapElement->properties.scenerymultiple.colour[0] & 0x1F);
-                    mapElement->properties.scenerymultiple.colour[0] &= 0xE0;
-                    mapElement->properties.scenerymultiple.colour[0] |= colour;
+                    colour = RCT1::GetColour(tileElement->properties.scenerymultiple.colour[0] & 0x1F);
+                    tileElement->properties.scenerymultiple.colour[0] &= 0xE0;
+                    tileElement->properties.scenerymultiple.colour[0] |= colour;
 
-                    colour = RCT1::GetColour(mapElement->properties.scenerymultiple.colour[1] & 0x1F);
-                    mapElement->properties.scenerymultiple.colour[1] &= 0xE0;
-                    mapElement->properties.scenerymultiple.colour[1] |= colour;
+                    colour = RCT1::GetColour(tileElement->properties.scenerymultiple.colour[1] & 0x1F);
+                    tileElement->properties.scenerymultiple.colour[1] &= 0xE0;
+                    tileElement->properties.scenerymultiple.colour[1] |= colour;
                     break;
                 }
             }
-            mapElement++;
+            tileElement++;
         }
     }
 
-    void FixMapElementZ()
+    void FixTileElementZ()
     {
-        rct_tile_element * mapElement = gMapElements;
-        while (mapElement < gNextFreeMapElement)
+        rct_tile_element * tileElement = gTileElements;
+        while (tileElement < gNextFreeTileElement)
         {
-            if (mapElement->base_height != 255)
+            if (tileElement->base_height != 255)
             {
-                mapElement->base_height /= 2;
-                mapElement->clearance_height /= 2;
+                tileElement->base_height /= 2;
+                tileElement->clearance_height /= 2;
             }
-            mapElement++;
+            tileElement++;
         }
         gMapBaseZ = 7;
     }
 
     void FixPaths()
     {
-        rct_tile_element * mapElement = gMapElements;
-        while (mapElement < gNextFreeMapElement)
+        rct_tile_element * tileElement = gTileElements;
+        while (tileElement < gNextFreeTileElement)
         {
-            switch (tile_element_get_type(mapElement)) {
+            switch (tile_element_get_type(tileElement)) {
             case TILE_ELEMENT_TYPE_PATH:
             {
                 // Type
-                uint8 pathColour = mapElement->type & 3;
-                uint8 pathType = (mapElement->properties.path.type & 0xF0) >> 4;
+                uint8 pathColour = tileElement->type & 3;
+                uint8 pathType = (tileElement->properties.path.type & 0xF0) >> 4;
 
                 pathType = (pathType << 2) | pathColour;
                 uint8 entryIndex = _pathTypeToEntryMap[pathType];
 
-                mapElement->type &= 0xFC;
-                mapElement->flags &= ~0x60;
-                mapElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
-                mapElement->properties.path.type &= 0x0F;
-                footpath_scenery_set_is_ghost(mapElement, false);
+                tileElement->type &= 0xFC;
+                tileElement->flags &= ~0x60;
+                tileElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
+                tileElement->properties.path.type &= 0x0F;
+                footpath_scenery_set_is_ghost(tileElement, false);
                 if (RCT1::PathIsQueue(pathType))
                 {
-                    mapElement->type |= 1;
+                    tileElement->type |= 1;
                 }
-                mapElement->properties.path.type |= entryIndex << 4;
+                tileElement->properties.path.type |= entryIndex << 4;
 
                 // Additions
-                uint8 additionType = footpath_element_get_path_scenery(mapElement);
+                uint8 additionType = footpath_element_get_path_scenery(tileElement);
                 if (additionType != RCT1_PATH_ADDITION_NONE)
                 {
                     uint8 normalisedType = RCT1::NormalisePathAddition(additionType);
                     entryIndex = _pathAdditionTypeToEntryMap[normalisedType];
                     if (additionType != normalisedType)
                     {
-                        mapElement->flags |= TILE_ELEMENT_FLAG_BROKEN;
+                        tileElement->flags |= TILE_ELEMENT_FLAG_BROKEN;
                     }
-                    footpath_element_set_path_scenery(mapElement, entryIndex + 1);
+                    footpath_element_set_path_scenery(tileElement, entryIndex + 1);
                 }
                 break;
             }
             case TILE_ELEMENT_TYPE_ENTRANCE:
-                if (mapElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE)
+                if (tileElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE)
                 {
-                    uint8 pathType = mapElement->properties.entrance.path_type;
+                    uint8 pathType = tileElement->properties.entrance.path_type;
                     if (pathType == 0)
                     {
                         pathType = RCT1_FOOTPATH_TYPE_TARMAC_GRAY;
                     }
                     uint8 entryIndex = _pathTypeToEntryMap[pathType];
-                    mapElement->properties.entrance.path_type = entryIndex & 0x7F;
+                    tileElement->properties.entrance.path_type = entryIndex & 0x7F;
                 }
                 break;
             }
-            mapElement++;
+            tileElement++;
         }
     }
 
@@ -2403,17 +2403,17 @@ private:
         {
             for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
             {
-                rct_tile_element * mapElement = map_get_first_element_at(x, y);
+                rct_tile_element * tileElement = map_get_first_element_at(x, y);
                 do
                 {
-                    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_WALL)
+                    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
                     {
-                        rct_tile_element originalMapElement = *mapElement;
-                        tile_element_remove(mapElement);
+                        rct_tile_element originalTileElement = *tileElement;
+                        tile_element_remove(tileElement);
 
-                        uint8 var_05 = originalMapElement.properties.wall.colour_3;
-                        uint16 var_06 = originalMapElement.properties.wall.colour_1 |
-                                       (originalMapElement.properties.wall.animation << 8);
+                        uint8 var_05 = originalTileElement.properties.wall.colour_3;
+                        uint16 var_06 = originalTileElement.properties.wall.colour_1 |
+                                       (originalTileElement.properties.wall.animation << 8);
 
                         for (sint32 edge = 0; edge < 4; edge++)
                         {
@@ -2422,8 +2422,8 @@ private:
                             if (typeB != 0x0F)
                             {
                                 sint32 type = typeA | (typeB << 2);
-                                sint32 colourA = ((originalMapElement.type & 0xC0) >> 3) |
-                                               (originalMapElement.properties.wall.type >> 5);
+                                sint32 colourA = ((originalTileElement.type & 0xC0) >> 3) |
+                                               (originalTileElement.properties.wall.type >> 5);
                                 sint32 colourB = 0;
                                 sint32 colourC = 0;
                                 ConvertWall(&type, &colourA, &colourB, &colourC);
@@ -2435,7 +2435,7 @@ private:
                         break;
                     }
                 }
-                while (!tile_element_is_last_for_tile(mapElement++));
+                while (!tile_element_is_last_for_tile(tileElement++));
             }
         }
 
@@ -2484,18 +2484,18 @@ private:
         {
             for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
             {
-                rct_tile_element * mapElement = map_get_first_element_at(x, y);
+                rct_tile_element * tileElement = map_get_first_element_at(x, y);
                 do
                 {
-                    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_BANNER)
+                    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_BANNER)
                     {
-                        uint8 index = mapElement->properties.banner.index;
+                        uint8 index = tileElement->properties.banner.index;
                         rct_banner * src = &_s4.banners[index];
                         rct_banner * dst = &gBanners[index];
                         ImportBanner(dst, src);
                     }
                 }
-                while (!tile_element_is_last_for_tile(mapElement++));
+                while (!tile_element_is_last_for_tile(tileElement++));
             }
         }
     }
@@ -2562,22 +2562,22 @@ private:
         }
     }
 
-    void FixMapElementEntryTypes()
+    void FixTileElementEntryTypes()
     {
         tile_element_iterator it;
         tile_element_iterator_begin(&it);
         while (tile_element_iterator_next(&it))
         {
-            rct_tile_element * mapElement = it.element;
-            switch (tile_element_get_type(mapElement)) {
+            rct_tile_element * tileElement = it.element;
+            switch (tile_element_get_type(tileElement)) {
             case TILE_ELEMENT_TYPE_SCENERY:
-                mapElement->properties.scenery.type = _smallSceneryTypeToEntryMap[mapElement->properties.scenery.type];
+                tileElement->properties.scenery.type = _smallSceneryTypeToEntryMap[tileElement->properties.scenery.type];
                 break;
             case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
             {
-                uint8 type = mapElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK;
-                mapElement->properties.scenerymultiple.type &= ~TILE_ELEMENT_LARGE_TYPE_MASK;
-                mapElement->properties.scenerymultiple.type |= _largeSceneryTypeToEntryMap[type];
+                uint8 type = tileElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK;
+                tileElement->properties.scenerymultiple.type &= ~TILE_ELEMENT_LARGE_TYPE_MASK;
+                tileElement->properties.scenerymultiple.type |= _largeSceneryTypeToEntryMap[type];
                 break;
             }
             }
@@ -2673,16 +2673,16 @@ private:
         {
             for (sint32 y = 0; y < RCT1_MAX_MAP_SIZE; y++)
             {
-                rct_tile_element * mapElement = map_get_first_element_at(x, y);
+                rct_tile_element * tileElement = map_get_first_element_at(x, y);
                 do
                 {
-                    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+                    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
                     {
                         // Lift hill tops are the only pieces present in RCT1 that can count as a block brake.
-                        if (!track_element_is_lift_hill(mapElement))
+                        if (!track_element_is_lift_hill(tileElement))
                             continue;
 
-                        uint8 trackType = mapElement->properties.track.type;
+                        uint8 trackType = tileElement->properties.track.type;
                         switch (trackType) {
                         case TRACK_ELEM_25_DEG_UP_TO_FLAT:
                         case TRACK_ELEM_60_DEG_UP_TO_FLAT:
@@ -2693,12 +2693,12 @@ private:
                             continue;
                         }
 
-                        uint8 rideIndex = mapElement->properties.track.ride_index;
+                        uint8 rideIndex = tileElement->properties.track.ride_index;
                         Ride * ride = get_ride(rideIndex);
                         ride->num_block_brakes++;
                     }
                 }
-                while (!tile_element_is_last_for_tile(mapElement++));
+                while (!tile_element_is_last_for_tile(tileElement++));
             }
         }
     }
diff --git a/src/openrct2/rct2/S6Exporter.cpp b/src/openrct2/rct2/S6Exporter.cpp
index 70f3d1d764..edb7a8a40e 100644
--- a/src/openrct2/rct2/S6Exporter.cpp
+++ b/src/openrct2/rct2/S6Exporter.cpp
@@ -183,9 +183,9 @@ void S6Exporter::Export()
     _s6.scenario_srand_0 = gScenarioSrand0;
     _s6.scenario_srand_1 = gScenarioSrand1;
 
-    memcpy(_s6.tile_elements, gMapElements, sizeof(_s6.tile_elements));
+    memcpy(_s6.tile_elements, gTileElements, sizeof(_s6.tile_elements));
 
-    _s6.next_free_tile_element_pointer_index = gNextFreeMapElementPointerIndex;
+    _s6.next_free_tile_element_pointer_index = gNextFreeTileElementPointerIndex;
     // Sprites needs to be reset before they get used.
     // Might as well reset them in here to zero out the space and improve
     // compression ratios. Especially useful for multiplayer servers that
diff --git a/src/openrct2/rct2/S6Importer.cpp b/src/openrct2/rct2/S6Importer.cpp
index 87dbeedab1..c370419e0b 100644
--- a/src/openrct2/rct2/S6Importer.cpp
+++ b/src/openrct2/rct2/S6Importer.cpp
@@ -198,9 +198,9 @@ public:
         gScenarioSrand0    = _s6.scenario_srand_0;
         gScenarioSrand1    = _s6.scenario_srand_1;
 
-        memcpy(gMapElements, _s6.tile_elements, sizeof(_s6.tile_elements));
+        memcpy(gTileElements, _s6.tile_elements, sizeof(_s6.tile_elements));
 
-        gNextFreeMapElementPointerIndex = _s6.next_free_tile_element_pointer_index;
+        gNextFreeTileElementPointerIndex = _s6.next_free_tile_element_pointer_index;
         for (sint32 i = 0; i < RCT2_MAX_SPRITES; i++)
         {
             memcpy(get_sprite(i), &_s6.sprites[i], sizeof(rct_sprite));
diff --git a/src/openrct2/ride/Station.cpp b/src/openrct2/ride/Station.cpp
index 9f7508526c..460ab4db79 100644
--- a/src/openrct2/ride/Station.cpp
+++ b/src/openrct2/ride/Station.cpp
@@ -57,13 +57,13 @@ void ride_update_station(Ride * ride, sint32 stationIndex)
  */
 static void ride_update_station_blocksection(Ride * ride, sint32 stationIndex)
 {
-    rct_tile_element * mapElement = ride_get_station_start_track_element(ride, stationIndex);
+    rct_tile_element * tileElement = ride_get_station_start_track_element(ride, stationIndex);
 
-    if ((ride->status == RIDE_STATUS_CLOSED && ride->num_riders == 0) || (mapElement != nullptr && mapElement->flags & 0x20))
+    if ((ride->status == RIDE_STATUS_CLOSED && ride->num_riders == 0) || (tileElement != nullptr && tileElement->flags & 0x20))
     {
         ride->station_depart[stationIndex] &= ~STATION_DEPART_FLAG;
 
-        if ((ride->station_depart[stationIndex] & STATION_DEPART_FLAG) || (mapElement != nullptr && tile_element_get_green_light(mapElement)))
+        if ((ride->station_depart[stationIndex] & STATION_DEPART_FLAG) || (tileElement != nullptr && tile_element_get_green_light(tileElement)))
             ride_invalidate_station_start(ride, stationIndex, false);
     }
     else
@@ -73,7 +73,7 @@ static void ride_update_station_blocksection(Ride * ride, sint32 stationIndex)
             ride->station_depart[stationIndex] |= STATION_DEPART_FLAG;
             ride_invalidate_station_start(ride, stationIndex, true);
         }
-        else if (mapElement != nullptr && tile_element_get_green_light(mapElement))
+        else if (tileElement != nullptr && tile_element_get_green_light(tileElement))
         {
             ride_invalidate_station_start(ride, stationIndex, true);
         }
@@ -296,16 +296,16 @@ static void ride_invalidate_station_start(Ride * ride, sint32 stationIndex, bool
 {
     sint32 x = ride->station_starts[stationIndex].x * 32;
     sint32 y = ride->station_starts[stationIndex].y * 32;
-    rct_tile_element * mapElement = ride_get_station_start_track_element(ride, stationIndex);
+    rct_tile_element * tileElement = ride_get_station_start_track_element(ride, stationIndex);
 
     // If no station track found return
-    if (mapElement == nullptr)
+    if (tileElement == nullptr)
         return;
 
-    tile_element_set_green_light(mapElement, greenLight);
+    tile_element_set_green_light(tileElement, greenLight);
 
     // Invalidate map tile
-    map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+    map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
 }
 
 rct_tile_element * ride_get_station_start_track_element(Ride * ride, sint32 stationIndex)
@@ -315,14 +315,14 @@ rct_tile_element * ride_get_station_start_track_element(Ride * ride, sint32 stat
     sint32 z = ride->station_heights[stationIndex];
 
     // Find the station track element
-    rct_tile_element * mapElement = map_get_first_element_at(x, y);
+    rct_tile_element * tileElement = map_get_first_element_at(x, y);
     do
     {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK && z == mapElement->base_height)
-            return mapElement;
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK && z == tileElement->base_height)
+            return tileElement;
 
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     return nullptr;
 }
@@ -330,13 +330,13 @@ rct_tile_element * ride_get_station_start_track_element(Ride * ride, sint32 stat
 rct_tile_element * ride_get_station_exit_element(Ride * ride, sint32 x, sint32 y, sint32 z)
 {
     // Find the station track element
-    rct_tile_element * mapElement = map_get_first_element_at(x, y);
+    rct_tile_element * tileElement = map_get_first_element_at(x, y);
     do
     {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE && z == mapElement->base_height)
-            return mapElement;
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE && z == tileElement->base_height)
+            return tileElement;
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     return nullptr;
 }
diff --git a/src/openrct2/ride/Track.cpp b/src/openrct2/ride/Track.cpp
index acbfb3b06f..cbe66b0fdd 100644
--- a/src/openrct2/ride/Track.cpp
+++ b/src/openrct2/ride/Track.cpp
@@ -605,23 +605,23 @@ const rct_preview_track * get_track_def_from_ride_index(sint32 rideIndex, sint32
 
 static rct_tile_element * find_station_element(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 rideIndex)
 {
-    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (z != mapElement->base_height)
+        if (z != tileElement->base_height)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
-        if (tile_element_get_direction(mapElement) != direction)
+        if (tile_element_get_direction(tileElement) != direction)
             continue;
-        if (mapElement->properties.track.ride_index != rideIndex)
+        if (tileElement->properties.track.ride_index != rideIndex)
             continue;
-        if (!track_element_is_station(mapElement))
+        if (!track_element_is_station(tileElement))
             continue;
 
-        return mapElement;
+        return tileElement;
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
     return nullptr;
 }
 
@@ -812,8 +812,8 @@ static bool track_remove_station_element(sint32 x, sint32 y, sint32 z, sint32 di
     Ride * ride = get_ride(rideIndex);
     if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3))
     {
-        rct_tile_element * mapElement = map_get_track_element_at_with_direction_from_ride(x, y, z, direction, rideIndex);
-        if (mapElement != nullptr)
+        rct_tile_element * tileElement = map_get_track_element_at_with_direction_from_ride(x, y, z, direction, rideIndex);
+        if (tileElement != nullptr)
         {
             if (flags & GAME_COMMAND_FLAG_APPLY)
             {
@@ -991,7 +991,7 @@ static money32 track_place(sint32 rideIndex,
         log_warning("Invalid ride type for track placement, rideIndex = %d", rideIndex);
         return MONEY32_UNDEFINED;
     }
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
 
     gCommandExpenditureType = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION;
     gCommandPosition.x = originX + 16;
@@ -1295,9 +1295,9 @@ static money32 track_place(sint32 rideIndex,
 
         if ((rideTypeFlags & RIDE_TYPE_FLAG_TRACK_MUST_BE_ON_WATER) && !byte_9D8150)
         {
-            mapElement = map_get_surface_element_at(x / 32, y / 32);
+            tileElement = map_get_surface_element_at(x / 32, y / 32);
 
-            uint8 water_height = map_get_water_height(mapElement) * 2;
+            uint8 water_height = map_get_water_height(tileElement) * 2;
             if (water_height == 0)
             {
                 gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ON_WATER;
@@ -1310,9 +1310,9 @@ static money32 track_place(sint32 rideIndex,
                 return MONEY32_UNDEFINED;
             }
             water_height -= 2;
-            if (water_height == mapElement->base_height)
+            if (water_height == tileElement->base_height)
             {
-                bh = mapElement->properties.surface.slope & 0x0F;
+                bh = tileElement->properties.surface.slope & 0x0F;
                 if (bh == 7 || bh == 11 || bh == 13 || bh == 14)
                 {
                     gGameCommandErrorText = STR_CAN_ONLY_BUILD_THIS_ON_WATER;
@@ -1362,10 +1362,10 @@ static money32 track_place(sint32 rideIndex,
             }
         }
         //6c5648 12 push
-        mapElement = map_get_surface_element_at(x / 32, y / 32);
+        tileElement = map_get_surface_element_at(x / 32, y / 32);
         if (!gCheatsDisableSupportLimits)
         {
-            sint32 ride_height = clearanceZ - mapElement->base_height;
+            sint32 ride_height = clearanceZ - tileElement->base_height;
             if (ride_height >= 0)
             {
 
@@ -1402,7 +1402,7 @@ static money32 track_place(sint32 rideIndex,
             }
         }
 
-        sint32 _support_height = baseZ - mapElement->base_height;
+        sint32 _support_height = baseZ - tileElement->base_height;
         if (_support_height < 0)
         {
             _support_height = 10;
@@ -1478,9 +1478,9 @@ static money32 track_place(sint32 rideIndex,
             ride->overall_view.y = y / 32;
         }
 
-        mapElement = tile_element_insert(x / 32, y / 32, baseZ, bl & 0xF);
-        assert(mapElement != nullptr);
-        mapElement->clearance_height = clearanceZ;
+        tileElement = tile_element_insert(x / 32, y / 32, baseZ, bl & 0xF);
+        assert(tileElement != nullptr);
+        tileElement->clearance_height = clearanceZ;
 
         uint8 map_type = direction;
         map_type |= TILE_ELEMENT_TYPE_TRACK;
@@ -1488,46 +1488,46 @@ static money32 track_place(sint32 rideIndex,
         {
             map_type |= (1 << 7);
         }
-        mapElement->type = map_type;
+        tileElement->type = map_type;
 
-        tile_element_set_track_sequence(mapElement, trackBlock->index);
-        mapElement->properties.track.ride_index = rideIndex;
-        mapElement->properties.track.type       = type;
-        mapElement->properties.track.colour     = 0;
+        tile_element_set_track_sequence(tileElement, trackBlock->index);
+        tileElement->properties.track.ride_index = rideIndex;
+        tileElement->properties.track.type       = type;
+        tileElement->properties.track.colour     = 0;
         if (flags & GAME_COMMAND_FLAG_GHOST)
         {
-            mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
+            tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
         }
 
         switch (type)
         {
         case TRACK_ELEM_WATERFALL:
-            map_animation_create(MAP_ANIMATION_TYPE_TRACK_WATERFALL, x, y, mapElement->base_height);
+            map_animation_create(MAP_ANIMATION_TYPE_TRACK_WATERFALL, x, y, tileElement->base_height);
             break;
         case TRACK_ELEM_RAPIDS:
-            map_animation_create(MAP_ANIMATION_TYPE_TRACK_RAPIDS, x, y, mapElement->base_height);
+            map_animation_create(MAP_ANIMATION_TYPE_TRACK_RAPIDS, x, y, tileElement->base_height);
             break;
         case TRACK_ELEM_WHIRLPOOL:
-            map_animation_create(MAP_ANIMATION_TYPE_TRACK_WHIRLPOOL, x, y, mapElement->base_height);
+            map_animation_create(MAP_ANIMATION_TYPE_TRACK_WHIRLPOOL, x, y, tileElement->base_height);
             break;
         case TRACK_ELEM_SPINNING_TUNNEL:
-            map_animation_create(MAP_ANIMATION_TYPE_TRACK_SPINNINGTUNNEL, x, y, mapElement->base_height);
+            map_animation_create(MAP_ANIMATION_TYPE_TRACK_SPINNINGTUNNEL, x, y, tileElement->base_height);
             break;
         }
         if (track_element_has_speed_setting(type))
         {
-            tile_element_set_brake_booster_speed(mapElement, brakeSpeed);
+            tile_element_set_brake_booster_speed(tileElement, brakeSpeed);
         }
         else
         {
-            track_element_set_seat_rotation(mapElement, seatRotation);
+            track_element_set_seat_rotation(tileElement, seatRotation);
         }
 
         if (liftHillAndAlternativeState & RIDE_TYPE_ALTERNATIVE_TRACK_TYPE)
         {
-            track_element_set_inverted(mapElement, true);
+            track_element_set_inverted(tileElement, true);
         }
-        track_element_set_colour_scheme(mapElement, colour);
+        track_element_set_colour_scheme(tileElement, colour);
 
         if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
         {
@@ -1552,12 +1552,12 @@ static money32 track_place(sint32 rideIndex,
         {
             rct_tile_element * surfaceElement = map_get_surface_element_at(x / 32, y / 32);
             surfaceElement->type |= (1 << 6);
-            mapElement = surfaceElement;
+            tileElement = surfaceElement;
         }
 
         if (!gCheatsDisableClearanceChecks || !(flags & GAME_COMMAND_FLAG_GHOST))
         {
-            footpath_connect_edges(x, y, mapElement, flags);
+            footpath_connect_edges(x, y, tileElement, flags);
         }
         map_invalidate_tile_full(x, y);
     }
@@ -1645,29 +1645,29 @@ static money32 track_remove(uint8 type,
     }
 
     uint8 found = 0;
-    rct_tile_element * mapElement = map_get_first_element_at(originX / 32, originY / 32);
-    if (mapElement == nullptr)
+    rct_tile_element * tileElement = map_get_first_element_at(originX / 32, originY / 32);
+    if (tileElement == nullptr)
     {
         log_warning("Invalid coordinates for track removal. x = %d, y = %d", originX, originY);
         return MONEY32_UNDEFINED;
     }
     do
     {
-        if (mapElement->base_height * 8 != originZ)
+        if (tileElement->base_height * 8 != originZ)
             continue;
 
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if ((tile_element_get_direction(mapElement)) != rotation)
+        if ((tile_element_get_direction(tileElement)) != rotation)
             continue;
 
-        if (tile_element_get_track_sequence(mapElement) != sequence)
+        if (tile_element_get_track_sequence(tileElement) != sequence)
             continue;
 
         // Probably should add a check for ghost here as well!
 
-        uint8 track_type = mapElement->properties.track.type;
+        uint8 track_type = tileElement->properties.track.type;
         switch (track_type)
         {
         case TRACK_ELEM_BEGIN_STATION:
@@ -1682,28 +1682,28 @@ static money32 track_remove(uint8 type,
         found = 1;
         break;
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     if (!found)
     {
         return MONEY32_UNDEFINED;
     }
 
-    if (mapElement->flags & TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE)
+    if (tileElement->flags & TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE)
     {
         gGameCommandErrorText = STR_YOU_ARE_NOT_ALLOWED_TO_REMOVE_THIS_SECTION;
         return MONEY32_UNDEFINED;
     }
 
-    uint8 rideIndex = mapElement->properties.track.ride_index;
-    type = mapElement->properties.track.type;
-    bool isLiftHill = track_element_is_lift_hill(mapElement);
+    uint8 rideIndex = tileElement->properties.track.ride_index;
+    type = tileElement->properties.track.type;
+    bool isLiftHill = track_element_is_lift_hill(tileElement);
 
     Ride                    * ride       = get_ride(rideIndex);
     const rct_preview_track * trackBlock = get_track_def_from_ride(ride, type);
-    trackBlock += tile_element_get_track_sequence(mapElement);
+    trackBlock += tile_element_get_track_sequence(tileElement);
 
-    uint8 originDirection = tile_element_get_direction(mapElement);
+    uint8 originDirection = tile_element_get_direction(tileElement);
     switch (originDirection)
     {
     case 0:
@@ -1760,31 +1760,31 @@ static money32 track_remove(uint8 type,
         trackpieceZ = z;
 
         found      = 0;
-        mapElement = map_get_first_element_at(x / 32, y / 32);
+        tileElement = map_get_first_element_at(x / 32, y / 32);
         do
         {
-            if (mapElement == nullptr)
+            if (tileElement == nullptr)
                 break;
 
-            if (mapElement->base_height != z / 8)
+            if (tileElement->base_height != z / 8)
                 continue;
 
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                 continue;
 
-            if ((tile_element_get_direction(mapElement)) != rotation)
+            if ((tile_element_get_direction(tileElement)) != rotation)
                 continue;
 
-            if (tile_element_get_track_sequence(mapElement) != trackBlock->index)
+            if (tile_element_get_track_sequence(tileElement) != trackBlock->index)
                 continue;
 
-            if (mapElement->properties.track.type != type)
+            if (tileElement->properties.track.type != type)
                 continue;
 
             found = 1;
             break;
         }
-        while (!tile_element_is_last_for_tile(mapElement++));
+        while (!tile_element_is_last_for_tile(tileElement++));
 
         if (!found)
         {
@@ -1802,7 +1802,7 @@ static money32 track_remove(uint8 type,
             entranceDirections = TrackSequenceProperties[type][0];
         }
 
-        if (entranceDirections & TRACK_SEQUENCE_FLAG_ORIGIN && (tile_element_get_track_sequence(mapElement) == 0))
+        if (entranceDirections & TRACK_SEQUENCE_FLAG_ORIGIN && (tile_element_get_track_sequence(tileElement) == 0))
         {
             if (!track_remove_station_element(x, y, z / 8, rotation, rideIndex, 0))
             {
@@ -1816,7 +1816,7 @@ static money32 track_remove(uint8 type,
             return MONEY32_UNDEFINED;
         }
 
-        sint8 _support_height = mapElement->base_height - surfaceElement->base_height;
+        sint8 _support_height = tileElement->base_height - surfaceElement->base_height;
         if (_support_height < 0)
         {
             _support_height = 10;
@@ -1827,7 +1827,7 @@ static money32 track_remove(uint8 type,
         if (!(flags & GAME_COMMAND_FLAG_APPLY))
             continue;
 
-        if (entranceDirections & (1 << 4) && (tile_element_get_track_sequence(mapElement) == 0))
+        if (entranceDirections & (1 << 4) && (tile_element_get_track_sequence(tileElement) == 0))
         {
             if (!track_remove_station_element(x, y, z / 8, rotation, rideIndex, GAME_COMMAND_FLAG_APPLY))
             {
@@ -1842,11 +1842,11 @@ static money32 track_remove(uint8 type,
 
         invalidate_test_results(rideIndex);
         footpath_queue_chain_reset();
-        if (!gCheatsDisableClearanceChecks || !(mapElement->flags & TILE_ELEMENT_FLAG_GHOST))
+        if (!gCheatsDisableClearanceChecks || !(tileElement->flags & TILE_ELEMENT_FLAG_GHOST))
         {
-            footpath_remove_edges_at(x, y, mapElement);
+            footpath_remove_edges_at(x, y, tileElement);
         }
-        tile_element_remove(mapElement);
+        tile_element_remove(tileElement);
         if (!(flags & GAME_COMMAND_FLAG_GHOST))
         {
             sub_6CB945(rideIndex);
@@ -2030,8 +2030,8 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
         return MONEY32_UNDEFINED;
     }
 
-    rct_tile_element * mapElement = map_get_surface_element_at(x / 32, y / 32);
-    if (mapElement == nullptr)
+    rct_tile_element * tileElement = map_get_surface_element_at(x / 32, y / 32);
+    if (tileElement == nullptr)
     {
         return MONEY32_UNDEFINED;
     }
@@ -2039,7 +2039,7 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
     uint8 baseHeight      = z >> 3;
     uint8 clearanceHeight = (z + 32) >> 3;
 
-    sint8 heightDifference = baseHeight - mapElement->base_height;
+    sint8 heightDifference = baseHeight - tileElement->base_height;
     if (heightDifference >= 0 && !gCheatsDisableSupportLimits)
     {
         heightDifference = heightDifference >> 1;
@@ -2051,8 +2051,8 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
         }
     }
 
-    mapElement = map_get_track_element_at_of_type_from_ride(x, y, baseHeight, TRACK_ELEM_MAZE, rideIndex);
-    if (mapElement == nullptr)
+    tileElement = map_get_track_element_at_of_type_from_ride(x, y, baseHeight, TRACK_ELEM_MAZE, rideIndex);
+    if (tileElement == nullptr)
     {
         if (mode != GC_SET_MAZE_TRACK_BUILD)
         {
@@ -2095,23 +2095,23 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
         uint16 flooredX = floor2(x, 32);
         uint16 flooredY = floor2(y, 32);
 
-        mapElement = tile_element_insert(x / 32, y / 32, baseHeight, 0xF);
-        assert(mapElement != nullptr);
-        mapElement->clearance_height            = clearanceHeight;
-        mapElement->type                        = TILE_ELEMENT_TYPE_TRACK;
-        mapElement->properties.track.type       = TRACK_ELEM_MAZE;
-        mapElement->properties.track.ride_index = rideIndex;
-        mapElement->properties.track.maze_entry = 0xFFFF;
+        tileElement = tile_element_insert(x / 32, y / 32, baseHeight, 0xF);
+        assert(tileElement != nullptr);
+        tileElement->clearance_height            = clearanceHeight;
+        tileElement->type                        = TILE_ELEMENT_TYPE_TRACK;
+        tileElement->properties.track.type       = TRACK_ELEM_MAZE;
+        tileElement->properties.track.ride_index = rideIndex;
+        tileElement->properties.track.maze_entry = 0xFFFF;
 
         if (flags & GAME_COMMAND_FLAG_GHOST)
         {
-            mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
+            tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
         }
 
         map_invalidate_tile_full(flooredX, flooredY);
 
         ride->maze_tiles++;
-        ride->station_heights[0] = mapElement->base_height;
+        ride->station_heights[0] = tileElement->base_height;
         ride->station_starts[0].xy = 0;
 
         if (direction == 4)
@@ -2141,12 +2141,12 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
     {
         uint8 segmentOffset = maze_element_get_segment_bit(x, y);
 
-        mapElement->properties.track.maze_entry &= ~(1 << segmentOffset);
+        tileElement->properties.track.maze_entry &= ~(1 << segmentOffset);
 
         if (direction != 4)
         {
             segmentOffset = byte_993CE9[(direction + segmentOffset)];
-            mapElement->properties.track.maze_entry &= ~(1 << segmentOffset);
+            tileElement->properties.track.maze_entry &= ~(1 << segmentOffset);
 
             uint8 temp_edx = byte_993CFC[segmentOffset];
             if (temp_edx != 0xFF)
@@ -2154,19 +2154,19 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
                 uint16 previousElementX = floor2(x, 32) - TileDirectionDelta[direction].x;
                 uint16 previousElementY = floor2(y, 32) - TileDirectionDelta[direction].y;
 
-                rct_tile_element * previousMapElement = map_get_track_element_at_of_type_from_ride(
+                rct_tile_element * previousTileElement = map_get_track_element_at_of_type_from_ride(
                     previousElementX,
                     previousElementY,
                     baseHeight,
                     TRACK_ELEM_MAZE,
                     rideIndex);
-                if (previousMapElement != nullptr)
+                if (previousTileElement != nullptr)
                 {
-                    previousMapElement->properties.track.maze_entry &= ~(1 << temp_edx);
+                    previousTileElement->properties.track.maze_entry &= ~(1 << temp_edx);
                 }
                 else
                 {
-                    mapElement->properties.track.maze_entry |= (1 << segmentOffset);
+                    tileElement->properties.track.maze_entry |= (1 << segmentOffset);
                 }
             }
         }
@@ -2183,14 +2183,14 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
             uint16 previousSegmentX = x - TileDirectionDelta[direction].x / 2;
             uint16 previousSegmentY = y - TileDirectionDelta[direction].y / 2;
 
-            mapElement = map_get_track_element_at_of_type_from_ride(
+            tileElement = map_get_track_element_at_of_type_from_ride(
                 previousSegmentX,
                 previousSegmentY,
                 baseHeight,
                 TRACK_ELEM_MAZE,
                 rideIndex);
             map_invalidate_tile_full(floor2(previousSegmentX, 32), floor2(previousSegmentY, 32));
-            if (mapElement == nullptr)
+            if (tileElement == nullptr)
             {
                 log_error("No surface found");
                 return MONEY32_UNDEFINED;
@@ -2198,31 +2198,31 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
 
             uint32 segmentBit = maze_element_get_segment_bit(previousSegmentX, previousSegmentY);
 
-            mapElement->properties.track.maze_entry |= (1 << segmentBit);
+            tileElement->properties.track.maze_entry |= (1 << segmentBit);
             segmentBit--;
-            mapElement->properties.track.maze_entry |= (1 << segmentBit);
+            tileElement->properties.track.maze_entry |= (1 << segmentBit);
             segmentBit = (segmentBit - 4) & 0x0F;
-            mapElement->properties.track.maze_entry |= (1 << segmentBit);
+            tileElement->properties.track.maze_entry |= (1 << segmentBit);
             segmentBit = (segmentBit + 3) & 0x0F;
 
             do
             {
-                mapElement->properties.track.maze_entry |= (1 << segmentBit);
+                tileElement->properties.track.maze_entry |= (1 << segmentBit);
 
                 uint32 direction1   = byte_993D0C[segmentBit];
                 uint16 nextElementX = floor2(previousSegmentX, 32) + TileDirectionDelta[direction1].x;
                 uint16 nextElementY = floor2(previousSegmentY, 32) + TileDirectionDelta[direction1].y;
 
-                rct_tile_element * tmp_mapElement = map_get_track_element_at_of_type_from_ride(
+                rct_tile_element * tmp_tileElement = map_get_track_element_at_of_type_from_ride(
                     nextElementX,
                     nextElementY,
                     baseHeight,
                     TRACK_ELEM_MAZE,
                     rideIndex);
-                if (tmp_mapElement != nullptr)
+                if (tmp_tileElement != nullptr)
                 {
                     uint8 edx11 = byte_993CFC[segmentBit];
-                    tmp_mapElement->properties.track.maze_entry |= 1 << (edx11);
+                    tmp_tileElement->properties.track.maze_entry |= 1 << (edx11);
                 }
 
                 segmentBit--;
@@ -2232,11 +2232,11 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
         break;
     }
 
-    map_invalidate_tile(floor2(x, 32), floor2(y, 32), mapElement->base_height * 8, mapElement->clearance_height * 8);
+    map_invalidate_tile(floor2(x, 32), floor2(y, 32), tileElement->base_height * 8, tileElement->clearance_height * 8);
 
-    if ((mapElement->properties.track.maze_entry & 0x8888) == 0x8888)
+    if ((tileElement->properties.track.maze_entry & 0x8888) == 0x8888)
     {
-        tile_element_remove(mapElement);
+        tile_element_remove(tileElement);
         sub_6CB945(rideIndex);
         get_ride(rideIndex)->maze_tiles--;
     }
@@ -2301,8 +2301,8 @@ void game_command_set_brakes_speed(sint32 * eax,
         return;
     }
 
-    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
-    if (mapElement == nullptr)
+    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
+    if (tileElement == nullptr)
     {
         log_warning("Invalid game command for setting brakes speed. x = %d, y = %d", x, y);
         *ebx = MONEY32_UNDEFINED;
@@ -2310,18 +2310,18 @@ void game_command_set_brakes_speed(sint32 * eax,
     }
     do
     {
-        if (mapElement->base_height * 8 != z)
+        if (tileElement->base_height * 8 != z)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
-        if (mapElement->properties.track.type != trackType)
+        if (tileElement->properties.track.type != trackType)
             continue;
 
-        tile_element_set_brake_booster_speed(mapElement, brakesSpeed);
+        tile_element_set_brake_booster_speed(tileElement, brakesSpeed);
 
         break;
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     *ebx = 0;
 }
@@ -2489,27 +2489,27 @@ void track_element_clear_cable_lift(rct_tile_element * trackElement)
     trackElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
 }
 
-bool track_element_is_inverted(rct_tile_element * mapElement)
+bool track_element_is_inverted(rct_tile_element * tileElement)
 {
-    return mapElement->properties.track.colour & TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
+    return tileElement->properties.track.colour & TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
 }
 
-void track_element_set_inverted(rct_tile_element * mapElement, bool inverted)
+void track_element_set_inverted(rct_tile_element * tileElement, bool inverted)
 {
     if (inverted)
     {
-        mapElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
+        tileElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
     }
     else
     {
-        mapElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
+        tileElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
     }
 }
 
-sint32 track_get_actual_bank(rct_tile_element * mapElement, sint32 bank)
+sint32 track_get_actual_bank(rct_tile_element * tileElement, sint32 bank)
 {
-    Ride * ride        = get_ride(mapElement->properties.track.ride_index);
-    sint32 trackColour = mapElement->properties.track.colour;
+    Ride * ride        = get_ride(tileElement->properties.track.ride_index);
+    sint32 trackColour = tileElement->properties.track.colour;
     return track_get_actual_bank_2(ride->type, trackColour, bank);
 }
 
@@ -2532,12 +2532,12 @@ sint32 track_get_actual_bank_2(sint32 rideType, sint32 trackColour, sint32 bank)
     return bank;
 }
 
-sint32 track_get_actual_bank_3(rct_vehicle * vehicle, rct_tile_element * mapElement)
+sint32 track_get_actual_bank_3(rct_vehicle * vehicle, rct_tile_element * tileElement)
 {
     uint8  colourThingToXor = (vehicle->update_flags >> 9) & 0xFF;
-    sint32 trackType        = mapElement->properties.track.type;
-    sint32 rideType         = get_ride(mapElement->properties.track.ride_index)->type;
-    sint32 trackColour      = mapElement->properties.track.colour ^ colourThingToXor;
+    sint32 trackType        = tileElement->properties.track.type;
+    sint32 rideType         = get_ride(tileElement->properties.track.ride_index)->type;
+    sint32 trackColour      = tileElement->properties.track.colour ^ colourThingToXor;
     sint32 bankStart        = TrackDefinitions[trackType].bank_start;
     return track_get_actual_bank_2(rideType, trackColour, bankStart);
 }
@@ -2605,24 +2605,24 @@ bool track_element_has_speed_setting(uint8 trackType)
     return false;
 }
 
-uint8 track_element_get_seat_rotation(const rct_tile_element * mapElement)
+uint8 track_element_get_seat_rotation(const rct_tile_element * tileElement)
 {
-    return mapElement->properties.track.colour >> 4;
+    return tileElement->properties.track.colour >> 4;
 }
 
-void track_element_set_seat_rotation(rct_tile_element * mapElement, uint8 seatRotation)
+void track_element_set_seat_rotation(rct_tile_element * tileElement, uint8 seatRotation)
 {
-    mapElement->properties.track.colour &= 0x0F;
-    mapElement->properties.track.colour |= (seatRotation << 4);
+    tileElement->properties.track.colour &= 0x0F;
+    tileElement->properties.track.colour |= (seatRotation << 4);
 }
 
-uint8 track_element_get_colour_scheme(const rct_tile_element * mapElement)
+uint8 track_element_get_colour_scheme(const rct_tile_element * tileElement)
 {
-    return mapElement->properties.track.colour & 0x3;
+    return tileElement->properties.track.colour & 0x3;
 }
 
-void track_element_set_colour_scheme(rct_tile_element * mapElement, uint8 colourScheme)
+void track_element_set_colour_scheme(rct_tile_element * tileElement, uint8 colourScheme)
 {
-    mapElement->properties.track.colour &= ~0x3;
-    mapElement->properties.track.colour |= (colourScheme & 0x3);
+    tileElement->properties.track.colour &= ~0x3;
+    tileElement->properties.track.colour |= (colourScheme & 0x3);
 }
diff --git a/src/openrct2/ride/Track.h b/src/openrct2/ride/Track.h
index ec73361f6c..58f4ea489d 100644
--- a/src/openrct2/ride/Track.h
+++ b/src/openrct2/ride/Track.h
@@ -548,12 +548,12 @@ bool track_element_is_lift_hill(rct_tile_element * trackElement);
 bool track_element_is_cable_lift(rct_tile_element * trackElement);
 void track_element_set_cable_lift(rct_tile_element * trackElement);
 void track_element_clear_cable_lift(rct_tile_element * trackElement);
-bool track_element_is_inverted(rct_tile_element * mapElement);
-void track_element_set_inverted(rct_tile_element * mapElement, bool inverted);
+bool track_element_is_inverted(rct_tile_element * tileElement);
+void track_element_set_inverted(rct_tile_element * tileElement, bool inverted);
 
-sint32 track_get_actual_bank(rct_tile_element * mapElement, sint32 bank);
+sint32 track_get_actual_bank(rct_tile_element * tileElement, sint32 bank);
 sint32 track_get_actual_bank_2(sint32 rideType, sint32 trackColour, sint32 bank);
-sint32 track_get_actual_bank_3(rct_vehicle * vehicle, rct_tile_element * mapElement);
+sint32 track_get_actual_bank_3(rct_vehicle * vehicle, rct_tile_element * tileElement);
 
 void game_command_place_track(sint32 * eax, sint32 * ebx, sint32 * ecx, sint32 * edx, sint32 * esi, sint32 * edi, sint32 * ebp);
 void game_command_remove_track(sint32 * eax, sint32 * ebx, sint32 * ecx, sint32 * edx, sint32 * esi, sint32 * edi, sint32 * ebp);
@@ -561,10 +561,10 @@ void game_command_set_maze_track(sint32 * eax, sint32 * ebx, sint32 * ecx, sint3
 void game_command_set_brakes_speed(sint32 * eax, sint32 * ebx, sint32 * ecx, sint32 * edx, sint32 * esi, sint32 * edi, sint32 * ebp);
 bool track_element_is_booster(uint8 rideType, uint8 trackType);
 bool track_element_has_speed_setting(uint8 trackType);
-uint8 track_element_get_seat_rotation(const rct_tile_element * mapElement);
-void track_element_set_seat_rotation(rct_tile_element * mapElement, uint8 seatRotation);
-uint8 track_element_get_colour_scheme(const rct_tile_element * mapElement);
-void track_element_set_colour_scheme(rct_tile_element * mapElement, uint8 colourScheme);
+uint8 track_element_get_seat_rotation(const rct_tile_element * tileElement);
+void track_element_set_seat_rotation(rct_tile_element * tileElement, uint8 seatRotation);
+uint8 track_element_get_colour_scheme(const rct_tile_element * tileElement);
+void track_element_set_colour_scheme(rct_tile_element * tileElement, uint8 colourScheme);
 
 #ifdef __cplusplus
 }
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index 3cae2c2011..c5ae636ceb 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -1478,23 +1478,23 @@ static bool track_design_place_ride(rct_track_td6 * td6, sint16 x, sint16 y, sin
                     continue;
                 }
 
-                rct_tile_element * mapElement = map_get_surface_element_at(tile.x >> 5, tile.y >> 5);
-                if (mapElement == NULL)
+                rct_tile_element * tileElement = map_get_surface_element_at(tile.x >> 5, tile.y >> 5);
+                if (tileElement == NULL)
                 {
                     return false;
                 }
 
-                sint32 height = mapElement->base_height * 8;
-                if (mapElement->properties.surface.slope & 0x0F)
+                sint32 height = tileElement->base_height * 8;
+                if (tileElement->properties.surface.slope & 0x0F)
                 {
                     height += 16;
-                    if (mapElement->properties.surface.slope & 0x10)
+                    if (tileElement->properties.surface.slope & 0x10)
                     {
                         height += 16;
                     }
                 }
 
-                uint8 water_height = map_get_water_height(mapElement) * 16;
+                uint8 water_height = map_get_water_height(tileElement) * 16;
                 if (water_height > 0 && water_height > height)
                 {
                     height = water_height;
@@ -2041,11 +2041,11 @@ static money32 place_maze_design(uint8 flags, uint8 rideIndex, uint16 mazeEntry,
     // Check support height
     if (!gCheatsDisableSupportLimits)
     {
-        rct_tile_element * mapElement = map_get_surface_element_at(x >> 5, y >> 5);
+        rct_tile_element * tileElement = map_get_surface_element_at(x >> 5, y >> 5);
         uint8           supportZ     = (z + 32) >> 3;
-        if (supportZ > mapElement->base_height)
+        if (supportZ > tileElement->base_height)
         {
-            uint8 supportHeight    = (supportZ - mapElement->base_height) / 2;
+            uint8 supportHeight    = (supportZ - tileElement->base_height) / 2;
             uint8 maxSupportHeight = RideData5[RIDE_TYPE_MAZE].max_height;
             if (supportHeight > maxSupportHeight)
             {
@@ -2109,21 +2109,21 @@ static money32 place_maze_design(uint8 flags, uint8 rideIndex, uint16 mazeEntry,
         sint32          fx           = floor2(x, 32);
         sint32          fy           = floor2(y, 32);
         sint32          fz           = z >> 3;
-        rct_tile_element * mapElement = tile_element_insert(fx >> 5, fy >> 5, fz, 15);
-        mapElement->clearance_height            = fz + 4;
-        mapElement->type                        = TILE_ELEMENT_TYPE_TRACK;
-        mapElement->properties.track.type       = TRACK_ELEM_MAZE;
-        mapElement->properties.track.ride_index = rideIndex;
-        mapElement->properties.track.maze_entry = mazeEntry;
+        rct_tile_element * tileElement = tile_element_insert(fx >> 5, fy >> 5, fz, 15);
+        tileElement->clearance_height            = fz + 4;
+        tileElement->type                        = TILE_ELEMENT_TYPE_TRACK;
+        tileElement->properties.track.type       = TRACK_ELEM_MAZE;
+        tileElement->properties.track.ride_index = rideIndex;
+        tileElement->properties.track.maze_entry = mazeEntry;
         if (flags & GAME_COMMAND_FLAG_GHOST)
         {
-            mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
+            tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
         }
 
-        map_invalidate_element(fx, fy, mapElement);
+        map_invalidate_element(fx, fy, tileElement);
 
         ride->maze_tiles++;
-        ride->station_heights[0] = mapElement->base_height;
+        ride->station_heights[0] = tileElement->base_height;
         ride->station_starts[0].xy = 0;
         if (ride->maze_tiles == 1)
         {
@@ -2286,15 +2286,15 @@ static map_backup * track_design_preview_backup_map()
     {
         memcpy(
             backup->tile_elements,
-            gMapElements,
+            gTileElements,
             sizeof(backup->tile_elements)
         );
         memcpy(
             backup->tile_pointers,
-            gMapElementTilePointers,
+            gTileElementTilePointers,
             sizeof(backup->tile_pointers)
         );
-        backup->next_free_tile_element  = gNextFreeMapElement;
+        backup->next_free_tile_element  = gNextFreeTileElement;
         backup->map_size_units         = gMapSizeUnits;
         backup->map_size_units_minus_2 = gMapSizeMinus2;
         backup->map_size               = gMapSize;
@@ -2310,16 +2310,16 @@ static map_backup * track_design_preview_backup_map()
 static void track_design_preview_restore_map(map_backup * backup)
 {
     memcpy(
-        gMapElements,
+        gTileElements,
         backup->tile_elements,
         sizeof(backup->tile_elements)
     );
     memcpy(
-        gMapElementTilePointers,
+        gTileElementTilePointers,
         backup->tile_pointers,
         sizeof(backup->tile_pointers)
     );
-    gNextFreeMapElement = backup->next_free_tile_element;
+    gNextFreeTileElement = backup->next_free_tile_element;
     gMapSizeUnits       = backup->map_size_units;
     gMapSizeMinus2      = backup->map_size_units_minus_2;
     gMapSize            = backup->map_size;
@@ -2342,7 +2342,7 @@ static void track_design_preview_clear_map()
 
     for (sint32 i = 0; i < MAX_TILE_TILE_ELEMENT_POINTERS; i++)
     {
-        rct_tile_element * tile_element = &gMapElements[i];
+        rct_tile_element * tile_element = &gTileElements[i];
         tile_element->type                            = TILE_ELEMENT_TYPE_SURFACE;
         tile_element->flags                           = TILE_ELEMENT_FLAG_LAST_TILE;
         tile_element->base_height                     = 2;
diff --git a/src/openrct2/ride/TrackDesign.h b/src/openrct2/ride/TrackDesign.h
index f34b1625f2..0a5e38723e 100644
--- a/src/openrct2/ride/TrackDesign.h
+++ b/src/openrct2/ride/TrackDesign.h
@@ -232,9 +232,9 @@ void track_design_draw_preview(rct_track_td6 *td6, uint8 *pixels);
 ///////////////////////////////////////////////////////////////////////////////
 void track_design_save_init();
 void track_design_save_reset_scenery();
-bool track_design_save_contains_tile_element(rct_tile_element *mapElement);
+bool track_design_save_contains_tile_element(rct_tile_element *tileElement);
 void track_design_save_select_nearby_scenery(sint32 rideIndex);
-void track_design_save_select_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *mapElement, bool collect);
+void track_design_save_select_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *tileElement, bool collect);
 bool track_design_save(uint8 rideIndex);
 bool track_design_save_to_file(const utf8 *path);
 
diff --git a/src/openrct2/ride/Vehicle.cpp b/src/openrct2/ride/Vehicle.cpp
index cee217f908..5084796455 100644
--- a/src/openrct2/ride/Vehicle.cpp
+++ b/src/openrct2/ride/Vehicle.cpp
@@ -2729,15 +2729,15 @@ static bool try_add_synchronised_station(sint32 x, sint32 y, sint32 z)
         return false;
     }
 
-    rct_tile_element * mapElement = get_station_platform(x, y, z, 2);
-    if (mapElement == NULL)
+    rct_tile_element * tileElement = get_station_platform(x, y, z, 2);
+    if (tileElement == NULL)
     {
         /* No station platform element found,
          * so no station to synchronise */
         return false;
     }
 
-    sint32 rideIndex = mapElement->properties.track.ride_index;
+    sint32 rideIndex = tileElement->properties.track.ride_index;
     Ride * ride      = get_ride(rideIndex);
     if (!(ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS))
     {
@@ -2749,7 +2749,7 @@ static bool try_add_synchronised_station(sint32 x, sint32 y, sint32 z)
      * to sync with adjacent stations, so it will return true.
      * Still to determine if a vehicle to sync can be identified. */
 
-    sint32 stationIndex = tile_element_get_station(mapElement);
+    sint32 stationIndex = tile_element_get_station(tileElement);
 
     rct_synchronised_vehicle * sv = _lastSynchronisedVehicle;
     sv->ride_id                   = rideIndex;
@@ -2829,8 +2829,8 @@ static bool vehicle_can_depart_synchronised(rct_vehicle * vehicle)
     sint32      y        = location.y * 32;
     sint32      z        = ride->station_heights[station];
 
-    rct_tile_element * mapElement = map_get_track_element_at(x, y, z);
-    if (mapElement == NULL)
+    rct_tile_element * tileElement = map_get_track_element_at(x, y, z);
+    if (tileElement == NULL)
     {
         return false;
     }
@@ -2843,7 +2843,7 @@ static bool vehicle_can_depart_synchronised(rct_vehicle * vehicle)
      *  is found we allow for space between that and the next.
      */
 
-    sint32 direction = (mapElement->type + 1) & 3;
+    sint32 direction = (tileElement->type + 1) & 3;
     sint32 spaceBetween;
     sint32 maxCheckDistance = RIDE_ADJACENCY_CHECK_DISTANCE;
 
@@ -3113,33 +3113,33 @@ void vehicle_test_reset(rct_vehicle * vehicle)
 
 static bool vehicle_next_tower_element_is_top(rct_vehicle * vehicle)
 {
-    rct_tile_element * mapElement =
+    rct_tile_element * tileElement =
         map_get_track_element_at_of_type(vehicle->track_x, vehicle->track_y, vehicle->track_z / 8, vehicle->track_type >> 2);
 
-    if (mapElement->flags & TILE_ELEMENT_FLAG_LAST_TILE)
+    if (tileElement->flags & TILE_ELEMENT_FLAG_LAST_TILE)
     {
         return true;
     }
 
-    if (mapElement->clearance_height == (mapElement + 1)->base_height)
+    if (tileElement->clearance_height == (tileElement + 1)->base_height)
     {
-        if ((mapElement + 1)->properties.track.type == TRACK_ELEM_TOWER_SECTION)
+        if ((tileElement + 1)->properties.track.type == TRACK_ELEM_TOWER_SECTION)
         {
             return false;
         }
     }
 
-    if ((mapElement + 1)->flags & TILE_ELEMENT_FLAG_LAST_TILE)
+    if ((tileElement + 1)->flags & TILE_ELEMENT_FLAG_LAST_TILE)
     {
         return true;
     }
 
-    if (mapElement->clearance_height != (mapElement + 2)->base_height)
+    if (tileElement->clearance_height != (tileElement + 2)->base_height)
     {
         return true;
     }
 
-    if ((mapElement + 2)->properties.track.type == TRACK_ELEM_TOWER_SECTION)
+    if ((tileElement + 2)->properties.track.type == TRACK_ELEM_TOWER_SECTION)
     {
         return false;
     }
@@ -3991,14 +3991,14 @@ loc_6D8E36:
         return;
     }
 
-    rct_tile_element * mapElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z / 8);
+    rct_tile_element * tileElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z / 8);
 
-    if (mapElement == NULL)
+    if (tileElement == NULL)
     {
         return;
     }
 
-    vehicle->current_station = tile_element_get_station(mapElement);
+    vehicle->current_station = tile_element_get_station(tileElement);
     vehicle->num_laps++;
 
     if (vehicle->sub_state != 0)
@@ -4278,10 +4278,10 @@ static void loc_6DA9F9(rct_vehicle * vehicle, sint32 x, sint32 y, sint32 bx, sin
         vehicle->track_x = bx;
         vehicle->track_y = dx;
 
-        rct_tile_element * mapElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3);
+        rct_tile_element * tileElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3);
 
         Ride * ride         = get_ride(vehicle->ride);
-        vehicle->track_type = (mapElement->properties.track.type << 2) | (ride->boat_hire_return_direction & 3);
+        vehicle->track_type = (tileElement->properties.track.type << 2) | (ride->boat_hire_return_direction & 3);
 
         vehicle->track_progress = 0;
         vehicle->status         = VEHICLE_STATUS_TRAVELLING;
@@ -4657,12 +4657,12 @@ static void vehicle_update_boat_location(rct_vehicle * vehicle)
 static bool vehicle_is_boat_on_water(rct_vehicle * vehicle, sint32 x, sint32 y)
 {
     sint32            z          = vehicle->track_z >> 3;
-    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SURFACE)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
         {
-            sint32 waterZ = map_get_water_height(mapElement) * 2;
+            sint32 waterZ = map_get_water_height(tileElement) * 2;
             if (z != waterZ)
             {
                 return true;
@@ -4670,12 +4670,12 @@ static bool vehicle_is_boat_on_water(rct_vehicle * vehicle, sint32 x, sint32 y)
         }
         else
         {
-            if (z > mapElement->base_height - 2 && z < mapElement->clearance_height + 2)
+            if (z > tileElement->base_height - 2 && z < tileElement->clearance_height + 2)
             {
                 return true;
             }
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return false;
 }
 
@@ -5157,8 +5157,8 @@ static void vehicle_update_doing_circus_show(rct_vehicle * vehicle)
  */
 static rct_tile_element * vehicle_check_collision(sint16 x, sint16 y, sint16 z)
 {
-    rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
-    if (mapElement == NULL)
+    rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
+    if (tileElement == NULL)
     {
         return NULL;
     }
@@ -5179,15 +5179,15 @@ static rct_tile_element * vehicle_check_collision(sint16 x, sint16 y, sint16 z)
 
     do
     {
-        if (z / 8 < mapElement->base_height)
+        if (z / 8 < tileElement->base_height)
             continue;
 
-        if (z / 8 >= mapElement->clearance_height)
+        if (z / 8 >= tileElement->clearance_height)
             continue;
 
-        if (mapElement->flags & bl)
-            return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        if (tileElement->flags & bl)
+            return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
@@ -6719,24 +6719,24 @@ static void update_velocity(rct_vehicle * vehicle)
     _vehicleVelocityF64E0C = (nextVelocity >> 10) * 42;
 }
 
-static void vehicle_update_block_brakes_open_previous_section(rct_vehicle * vehicle, rct_tile_element * mapElement)
+static void vehicle_update_block_brakes_open_previous_section(rct_vehicle * vehicle, rct_tile_element * tileElement)
 {
     sint32          x = vehicle->track_x;
     sint32          y = vehicle->track_y;
     sint32          z = vehicle->track_z;
     track_begin_end trackBeginEnd, slowTrackBeginEnd;
-    rct_tile_element slowMapElement = *mapElement;
+    rct_tile_element slowTileElement = *tileElement;
     bool            counter        = true;
     sint32          slowX          = x;
     sint32          slowY          = y;
     do
     {
-        if (!track_block_get_previous(x, y, mapElement, &trackBeginEnd))
+        if (!track_block_get_previous(x, y, tileElement, &trackBeginEnd))
         {
             return;
         }
         if (trackBeginEnd.begin_x == vehicle->track_x && trackBeginEnd.begin_y == vehicle->track_y &&
-            mapElement == trackBeginEnd.begin_element)
+            tileElement == trackBeginEnd.begin_element)
         {
             return;
         }
@@ -6744,18 +6744,18 @@ static void vehicle_update_block_brakes_open_previous_section(rct_vehicle * vehi
         x          = trackBeginEnd.end_x;
         y          = trackBeginEnd.end_y;
         z          = trackBeginEnd.begin_z;
-        mapElement = trackBeginEnd.begin_element;
+        tileElement = trackBeginEnd.begin_element;
 
         //#2081: prevent infinite loop
         counter = !counter;
         if (counter)
         {
-            track_block_get_previous(slowX, slowY, &slowMapElement, &slowTrackBeginEnd);
+            track_block_get_previous(slowX, slowY, &slowTileElement, &slowTrackBeginEnd);
             slowX          = slowTrackBeginEnd.end_x;
             slowY          = slowTrackBeginEnd.end_y;
-            slowMapElement = *(slowTrackBeginEnd.begin_element);
-            if (slowX == x && slowY == y && slowMapElement.base_height == mapElement->base_height &&
-                slowMapElement.type == mapElement->type)
+            slowTileElement = *(slowTrackBeginEnd.begin_element);
+            if (slowX == x && slowY == y && slowTileElement.base_height == tileElement->base_height &&
+                slowTileElement.type == tileElement->type)
             {
                 return;
             }
@@ -6766,15 +6766,15 @@ static void vehicle_update_block_brakes_open_previous_section(rct_vehicle * vehi
     x          = trackBeginEnd.begin_x;
     y          = trackBeginEnd.begin_y;
     z          = trackBeginEnd.begin_z;
-    mapElement = map_get_track_element_at(x, y, z >> 3);
-    if (mapElement == NULL)
+    tileElement = map_get_track_element_at(x, y, z >> 3);
+    if (tileElement == NULL)
     {
         return;
     }
-    mapElement->flags &= ~TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
-    map_invalidate_element(x, y, mapElement);
+    tileElement->flags &= ~TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
+    map_invalidate_element(x, y, tileElement);
 
-    sint32 trackType = mapElement->properties.track.type;
+    sint32 trackType = tileElement->properties.track.type;
     if (trackType == TRACK_ELEM_BLOCK_BRAKES || trackType == TRACK_ELEM_END_STATION)
     {
         Ride * ride = get_ride(vehicle->ride);
@@ -7198,8 +7198,8 @@ static void vehicle_update_spinning_car(rct_vehicle * vehicle)
  */
 static void steam_particle_create(sint16 x, sint16 y, sint16 z)
 {
-    rct_tile_element * mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-    if (mapElement != NULL && z > mapElement->base_height * 8)
+    rct_tile_element * tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+    if (tileElement != NULL && z > tileElement->base_height * 8)
     {
         rct_steam_particle * steam = (rct_steam_particle *)create_sprite(2);
         if (steam == NULL)
@@ -7364,9 +7364,9 @@ static void sub_6D63D4(rct_vehicle * vehicle)
  *
  *  rct2: 0x006DEDB1
  */
-static void vehicle_play_scenery_door_open_sound(rct_vehicle * vehicle, rct_tile_element * mapElement)
+static void vehicle_play_scenery_door_open_sound(rct_vehicle * vehicle, rct_tile_element * tileElement)
 {
-    rct_scenery_entry * wallEntry     = get_wall_entry(mapElement->properties.wall.type);
+    rct_scenery_entry * wallEntry     = get_wall_entry(tileElement->properties.wall.type);
     sint32              doorSoundType = (wallEntry->wall.flags2 >> 1) & 3;
     if (doorSoundType != 0)
     {
@@ -7382,9 +7382,9 @@ static void vehicle_play_scenery_door_open_sound(rct_vehicle * vehicle, rct_tile
  *
  *  rct2: 0x006DED7A
  */
-static void vehicle_play_scenery_door_close_sound(rct_vehicle * vehicle, rct_tile_element * mapElement)
+static void vehicle_play_scenery_door_close_sound(rct_vehicle * vehicle, rct_tile_element * tileElement)
 {
-    rct_scenery_entry * wallEntry     = get_wall_entry(mapElement->properties.wall.type);
+    rct_scenery_entry * wallEntry     = get_wall_entry(tileElement->properties.wall.type);
     sint32              doorSoundType = (wallEntry->wall.flags2 >> 1) & 3;
     if (doorSoundType != 0)
     {
@@ -7414,24 +7414,24 @@ static void vehicle_update_scenery_door(rct_vehicle * vehicle)
     sint32                        z                = (vehicle->track_z - trackBlock->z + trackCoordinates->z_end) >> 3;
     sint32                        direction        = (vehicle->track_direction + trackCoordinates->rotation_end) & 3;
 
-    rct_tile_element * mapElement = map_get_wall_element_at(x, y, z, direction);
-    if (mapElement == NULL)
+    rct_tile_element * tileElement = map_get_wall_element_at(x, y, z, direction);
+    if (tileElement == NULL)
     {
         return;
     }
 
     if (vehicle->next_vehicle_on_train != SPRITE_INDEX_NULL)
     {
-        mapElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
-        wall_element_set_animation_frame(mapElement, 1);
+        tileElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
+        wall_element_set_animation_frame(tileElement, 1);
         map_animation_create(MAP_ANIMATION_TYPE_WALL_DOOR, x, y, z);
-        vehicle_play_scenery_door_open_sound(vehicle, mapElement);
+        vehicle_play_scenery_door_open_sound(vehicle, tileElement);
     }
     else
     {
-        mapElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
-        wall_element_set_animation_frame(mapElement, 6);
-        vehicle_play_scenery_door_close_sound(vehicle, mapElement);
+        tileElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
+        wall_element_set_animation_frame(tileElement, 6);
+        vehicle_play_scenery_door_close_sound(vehicle, tileElement);
     }
 }
 
@@ -7439,13 +7439,13 @@ static void vehicle_update_scenery_door(rct_vehicle * vehicle)
  *
  *  rct2: 0x006DB38B
  */
-static bool loc_6DB38B(rct_vehicle * vehicle, rct_tile_element * mapElement)
+static bool loc_6DB38B(rct_vehicle * vehicle, rct_tile_element * tileElement)
 {
     // Get bank
-    sint32 bankStart = track_get_actual_bank_3(vehicle, mapElement);
+    sint32 bankStart = track_get_actual_bank_3(vehicle, tileElement);
 
     // Get vangle
-    sint32 trackType   = mapElement->properties.track.type;
+    sint32 trackType   = tileElement->properties.track.type;
     sint32 vangleStart = TrackDefinitions[trackType].vangle_start;
 
     if (vangleStart != _vehicleVAngleEndF64E36 || bankStart != _vehicleBankEndF64E37)
@@ -7477,11 +7477,11 @@ static void loc_6DB481(rct_vehicle * vehicle)
  *
  *  rct2: 0x006DB545
  */
-static void vehicle_trigger_on_ride_photo(rct_vehicle * vehicle, rct_tile_element * mapElement)
+static void vehicle_trigger_on_ride_photo(rct_vehicle * vehicle, rct_tile_element * tileElement)
 {
-    tile_element_set_onride_photo_timeout(mapElement);
+    tile_element_set_onride_photo_timeout(tileElement);
 
-    map_animation_create(MAP_ANIMATION_TYPE_TRACK_ONRIDEPHOTO, vehicle->track_x, vehicle->track_y, mapElement->base_height);
+    map_animation_create(MAP_ANIMATION_TYPE_TRACK_ONRIDEPHOTO, vehicle->track_x, vehicle->track_y, tileElement->base_height);
 }
 
 /**
@@ -7499,24 +7499,24 @@ static void vehicle_update_handle_scenery_door(rct_vehicle * vehicle)
     sint32                        direction        = (vehicle->track_direction + trackCoordinates->rotation_begin) & 3;
     direction ^= 2;
 
-    rct_tile_element * mapElement = map_get_wall_element_at(x, y, z, direction);
-    if (mapElement == NULL)
+    rct_tile_element * tileElement = map_get_wall_element_at(x, y, z, direction);
+    if (tileElement == NULL)
     {
         return;
     }
 
     if (vehicle->next_vehicle_on_train != SPRITE_INDEX_NULL)
     {
-        mapElement->properties.wall.animation |= WALL_ANIMATION_FLAG_DIRECTION_BACKWARD;
-        wall_element_set_animation_frame(mapElement, 1);
+        tileElement->properties.wall.animation |= WALL_ANIMATION_FLAG_DIRECTION_BACKWARD;
+        wall_element_set_animation_frame(tileElement, 1);
         map_animation_create(MAP_ANIMATION_TYPE_WALL_DOOR, x, y, z);
-        vehicle_play_scenery_door_open_sound(vehicle, mapElement);
+        vehicle_play_scenery_door_open_sound(vehicle, tileElement);
     }
     else
     {
-        mapElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
-        wall_element_set_animation_frame(mapElement, 6);
-        vehicle_play_scenery_door_close_sound(vehicle, mapElement);
+        tileElement->properties.wall.animation &= ~(WALL_ANIMATION_FLAG_DIRECTION_BACKWARD);
+        wall_element_set_animation_frame(tileElement, 6);
+        vehicle_play_scenery_door_close_sound(vehicle, tileElement);
     }
 }
 
@@ -7837,21 +7837,21 @@ static void sub_6DBF3E(rct_vehicle * vehicle)
 
     _vehicleMotionTrackFlags |= VEHICLE_UPDATE_MOTION_TRACK_FLAG_3;
 
-    rct_tile_element * mapElement = NULL;
+    rct_tile_element * tileElement = NULL;
     if (map_is_location_valid(vehicle->track_x, vehicle->track_y))
     {
-        mapElement =
+        tileElement =
             map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
     }
 
-    if (mapElement == NULL)
+    if (tileElement == NULL)
     {
         return;
     }
 
     if (_vehicleStationIndex == 0xFF)
     {
-        _vehicleStationIndex = tile_element_get_station(mapElement);
+        _vehicleStationIndex = tile_element_get_station(tileElement);
     }
 
     if (trackType == TRACK_ELEM_TOWER_BASE && vehicle == gCurrentVehicle)
@@ -7863,7 +7863,7 @@ static void sub_6DBF3E(rct_vehicle * vehicle)
 
             input.x       = vehicle->track_x;
             input.y       = vehicle->track_y;
-            input.element = mapElement;
+            input.element = tileElement;
             if (!track_block_get_next(&input, &output, &outputZ, &outputDirection))
             {
                 _vehicleMotionTrackFlags |= VEHICLE_UPDATE_MOTION_TRACK_FLAG_12;
@@ -7919,10 +7919,10 @@ static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle * veh
 
     _vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_end;
     _vehicleBankEndF64E37   = TrackDefinitions[trackType].bank_end;
-    rct_tile_element * mapElement =
+    rct_tile_element * tileElement =
         map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
 
-    if (mapElement == NULL)
+    if (tileElement == NULL)
     {
         return false;
     }
@@ -7932,11 +7932,11 @@ static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle * veh
         _vehicleMotionTrackFlags |= VEHICLE_UPDATE_MOTION_TRACK_FLAG_11;
     }
 
-    if (track_element_is_block_start(mapElement))
+    if (track_element_is_block_start(tileElement))
     {
         if (vehicle->next_vehicle_on_train == SPRITE_INDEX_NULL)
         {
-            mapElement->flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
+            tileElement->flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
             if (trackType == TRACK_ELEM_BLOCK_BRAKES || trackType == TRACK_ELEM_END_STATION)
             {
                 if (!(rideEntry->vehicles[0].flags & VEHICLE_ENTRY_FLAG_POWERED))
@@ -7944,8 +7944,8 @@ static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle * veh
                     audio_play_sound_at_location(SOUND_49, vehicle->track_x, vehicle->track_y, vehicle->track_z);
                 }
             }
-            map_invalidate_element(vehicle->track_x, vehicle->track_z, mapElement);
-            vehicle_update_block_brakes_open_previous_section(vehicle, mapElement);
+            map_invalidate_element(vehicle->track_x, vehicle->track_z, tileElement);
+            vehicle_update_block_brakes_open_previous_section(vehicle, tileElement);
         }
     }
 
@@ -7974,7 +7974,7 @@ static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle * veh
 loc_6DB32A:
 {
     track_begin_end trackBeginEnd;
-    if (!track_block_get_previous(vehicle->track_x, vehicle->track_y, mapElement, &trackBeginEnd))
+    if (!track_block_get_previous(vehicle->track_x, vehicle->track_y, tileElement, &trackBeginEnd))
     {
         return false;
     }
@@ -7982,7 +7982,7 @@ loc_6DB32A:
     regs.ecx   = trackBeginEnd.begin_y;
     regs.edx   = trackBeginEnd.begin_z;
     regs.bl    = trackBeginEnd.begin_direction;
-    mapElement = trackBeginEnd.begin_element;
+    tileElement = trackBeginEnd.begin_element;
 }
     goto loc_6DB41D;
 
@@ -7992,19 +7992,19 @@ loc_6DB358:
     sint32         z, direction;
     xyElement.x       = vehicle->track_x;
     xyElement.y       = vehicle->track_y;
-    xyElement.element = mapElement;
+    xyElement.element = tileElement;
     if (!track_block_get_next(&xyElement, &xyElement, &z, &direction))
     {
         return false;
     }
-    mapElement = xyElement.element;
+    tileElement = xyElement.element;
     regs.eax   = xyElement.x;
     regs.ecx   = xyElement.y;
     regs.edx   = z;
     regs.bl    = direction;
 }
-    if (mapElement->properties.track.type == TRACK_ELEM_LEFT_REVERSER ||
-        mapElement->properties.track.type == TRACK_ELEM_RIGHT_REVERSER)
+    if (tileElement->properties.track.type == TRACK_ELEM_LEFT_REVERSER ||
+        tileElement->properties.track.type == TRACK_ELEM_RIGHT_REVERSER)
     {
         if (!vehicle->is_child && vehicle->velocity <= 0x30000)
         {
@@ -8012,7 +8012,7 @@ loc_6DB358:
         }
     }
 
-    if (!loc_6DB38B(vehicle, mapElement))
+    if (!loc_6DB38B(vehicle, tileElement))
     {
         return false;
     }
@@ -8020,10 +8020,10 @@ loc_6DB358:
     // Update VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES flag
     vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
     {
-        sint32 rideType = get_ride(mapElement->properties.track.ride_index)->type;
+        sint32 rideType = get_ride(tileElement->properties.track.ride_index)->type;
         if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
         {
-            if (track_element_is_inverted(mapElement))
+            if (track_element_is_inverted(tileElement))
             {
                 vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
             }
@@ -8040,14 +8040,14 @@ loc_6DB41D:
 
     if ((vehicleEntry->flags & VEHICLE_ENTRY_FLAG_30) && vehicle->var_CD < 7)
     {
-        trackType = mapElement->properties.track.type;
+        trackType = tileElement->properties.track.type;
         if (trackType == TRACK_ELEM_FLAT)
         {
             loc_6DB481(vehicle);
         }
         else if (ride->lifecycle_flags & RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING)
         {
-            if (track_element_is_station(mapElement))
+            if (track_element_is_station(tileElement))
             {
                 loc_6DB481(vehicle);
             }
@@ -8072,25 +8072,25 @@ loc_6DB41D:
     // loc_6DB500
     // Update VEHICLE_UPDATE_FLAG_0
     vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_0;
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         vehicle->update_flags |= VEHICLE_UPDATE_FLAG_0;
     }
 
-    trackType = mapElement->properties.track.type;
+    trackType = tileElement->properties.track.type;
     if (trackType != TRACK_ELEM_BRAKES)
     {
-        vehicle->target_seat_rotation = track_element_get_seat_rotation(mapElement);
+        vehicle->target_seat_rotation = track_element_get_seat_rotation(tileElement);
     }
     vehicle->track_direction = regs.bl & 3;
     vehicle->track_type |= trackType << 2;
-    vehicle->brake_speed = tile_element_get_brake_booster_speed(mapElement);
+    vehicle->brake_speed = tile_element_get_brake_booster_speed(tileElement);
     if (trackType == TRACK_ELEM_ON_RIDE_PHOTO)
     {
-        vehicle_trigger_on_ride_photo(vehicle, mapElement);
+        vehicle_trigger_on_ride_photo(vehicle, tileElement);
     }
     {
-        uint16 rideType = get_ride(mapElement->properties.track.ride_index)->type;
+        uint16 rideType = get_ride(tileElement->properties.track.ride_index)->type;
         if (trackType == TRACK_ELEM_ROTATION_CONTROL_TOGGLE && rideType == RIDE_TYPE_WILD_MOUSE)
         {
             vehicle->update_flags ^= VEHICLE_UPDATE_FLAG_13;
@@ -8352,10 +8352,10 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
 {
     _vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_start;
     _vehicleBankEndF64E37   = TrackDefinitions[trackType].bank_start;
-    rct_tile_element * mapElement =
+    rct_tile_element * tileElement =
         map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
 
-    if (mapElement == NULL)
+    if (tileElement == NULL)
         return false;
 
     bool   nextTileBackwards = true;
@@ -8387,19 +8387,19 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
     {
         // loc_6DBB7E:;
         track_begin_end trackBeginEnd;
-        if (!track_block_get_previous(x, y, mapElement, &trackBeginEnd))
+        if (!track_block_get_previous(x, y, tileElement, &trackBeginEnd))
         {
             return false;
         }
-        mapElement = trackBeginEnd.begin_element;
+        tileElement = trackBeginEnd.begin_element;
 
-        trackType = mapElement->properties.track.type;
+        trackType = tileElement->properties.track.type;
         if (trackType == TRACK_ELEM_LEFT_REVERSER || trackType == TRACK_ELEM_RIGHT_REVERSER)
         {
             return false;
         }
 
-        sint32 trackColour = ((vehicle->update_flags >> 9) ^ mapElement->properties.track.colour) & 4;
+        sint32 trackColour = ((vehicle->update_flags >> 9) ^ tileElement->properties.track.colour) & 4;
         sint32 bank        = TrackDefinitions[trackType].bank_end;
         bank               = track_get_actual_bank_2(ride->type, trackColour, bank);
         sint32 vAngle      = TrackDefinitions[trackType].vangle_end;
@@ -8412,7 +8412,7 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
         vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
         if (RideData4[ride->type].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
         {
-            if (track_element_is_inverted(mapElement))
+            if (track_element_is_inverted(tileElement))
             {
                 vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
             }
@@ -8432,12 +8432,12 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
 
         input.x       = x;
         input.y       = y;
-        input.element = mapElement;
+        input.element = tileElement;
         if (!track_block_get_next(&input, &output, &outputZ, &direction))
         {
             return false;
         }
-        mapElement = output.element;
+        tileElement = output.element;
         x          = output.x;
         y          = output.y;
         z          = outputZ;
@@ -8462,13 +8462,13 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
         }
     }
 
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         if (_vehicleVelocityF64E08 < 0)
         {
             if (vehicle->next_vehicle_on_train == SPRITE_INDEX_NULL)
             {
-                trackType = mapElement->properties.track.type;
+                trackType = tileElement->properties.track.type;
                 if (!(TrackFlags[trackType] & TRACK_ELEM_FLAG_DOWN))
                 {
                     _vehicleMotionTrackFlags |= VEHICLE_UPDATE_MOTION_TRACK_FLAG_9;
@@ -8492,15 +8492,15 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle * ve
         }
     }
 
-    trackType = mapElement->properties.track.type;
+    trackType = tileElement->properties.track.type;
     if (trackType != TRACK_ELEM_BRAKES)
     {
-        vehicle->target_seat_rotation = track_element_get_seat_rotation(mapElement);
+        vehicle->target_seat_rotation = track_element_get_seat_rotation(tileElement);
     }
     direction &= 3;
     vehicle->track_type = trackType << 2;
     vehicle->track_direction |= direction;
-    vehicle->brake_speed = tile_element_get_brake_booster_speed(mapElement);
+    vehicle->brake_speed = tile_element_get_brake_booster_speed(tileElement);
 
     // There are two bytes before the move info list
     uint16 trackTotalProgress = vehicle_get_move_info_size(vehicle->var_CD, vehicle->track_type);
@@ -8678,7 +8678,7 @@ static sint32 vehicle_update_track_motion_mini_golf(rct_vehicle * vehicle, sint3
     rct_ride_entry *         rideEntry    = get_ride_entry(vehicle->ride_subtype);
     rct_ride_entry_vehicle * vehicleEntry = vehicle_get_vehicle_entry(vehicle);
 
-    rct_tile_element * mapElement = NULL;
+    rct_tile_element * tileElement = NULL;
 
     gCurrentVehicle          = vehicle;
     _vehicleMotionTrackFlags = 0;
@@ -8811,7 +8811,7 @@ loc_6DC476:
         uint16 trackType        = vehicle->track_type >> 2;
         _vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_end;
         _vehicleBankEndF64E37   = TrackDefinitions[trackType].bank_end;
-        mapElement =
+        tileElement =
             map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
     }
     sint16 x, y, z;
@@ -8821,29 +8821,29 @@ loc_6DC476:
         sint32         outZ, outDirection;
         input.x       = vehicle->track_x;
         input.y       = vehicle->track_y;
-        input.element = mapElement;
+        input.element = tileElement;
         if (!track_block_get_next(&input, &output, &outZ, &outDirection))
         {
             goto loc_6DC9BC;
         }
-        mapElement = output.element;
+        tileElement = output.element;
         x          = output.x;
         y          = output.y;
         z          = outZ;
         direction  = outDirection;
     }
 
-    if (!loc_6DB38B(vehicle, mapElement))
+    if (!loc_6DB38B(vehicle, tileElement))
     {
         goto loc_6DC9BC;
     }
 
     {
-        sint32 rideType = get_ride(mapElement->properties.track.ride_index)->type;
+        sint32 rideType = get_ride(tileElement->properties.track.ride_index)->type;
         vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
         if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
         {
-            if (track_element_is_inverted(mapElement))
+            if (track_element_is_inverted(tileElement))
             {
                 vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
             }
@@ -8866,8 +8866,8 @@ loc_6DC476:
     }
 
     vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_0;
-    vehicle->track_type = (mapElement->properties.track.type << 2) | (direction & 3);
-    vehicle->var_CF     = tile_element_get_brake_booster_speed(mapElement);
+    vehicle->track_type = (tileElement->properties.track.type << 2) | (direction & 3);
+    vehicle->var_CF     = tile_element_get_brake_booster_speed(tileElement);
     regs.ax             = 0;
 
 loc_6DC743:
@@ -9068,12 +9068,12 @@ loc_6DCA9A:
         _vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_end;
         _vehicleBankEndF64E37   = TrackDefinitions[trackType].bank_end;
 
-        mapElement =
+        tileElement =
             map_get_track_element_at_of_type_seq(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3, trackType, 0);
     }
     {
         track_begin_end trackBeginEnd;
-        if (!track_block_get_previous(vehicle->track_x, vehicle->track_y, mapElement, &trackBeginEnd))
+        if (!track_block_get_previous(vehicle->track_x, vehicle->track_y, tileElement, &trackBeginEnd))
         {
             goto loc_6DC9BC;
         }
@@ -9081,20 +9081,20 @@ loc_6DCA9A:
         y          = trackBeginEnd.begin_y;
         z          = trackBeginEnd.begin_z;
         direction  = trackBeginEnd.begin_direction;
-        mapElement = trackBeginEnd.begin_element;
+        tileElement = trackBeginEnd.begin_element;
     }
 
-    if (!loc_6DB38B(vehicle, mapElement))
+    if (!loc_6DB38B(vehicle, tileElement))
     {
         goto loc_6DCD4A;
     }
 
     {
-        sint32 rideType = get_ride(mapElement->properties.track.ride_index)->type;
+        sint32 rideType = get_ride(tileElement->properties.track.ride_index)->type;
         vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
         if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
         {
-            if (track_element_is_inverted(mapElement))
+            if (track_element_is_inverted(tileElement))
             {
                 vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
             }
@@ -9117,8 +9117,8 @@ loc_6DCA9A:
         }
     }
 
-    vehicle->track_type = (mapElement->properties.track.type << 2) | (direction & 3);
-    vehicle->var_CF     = (mapElement->properties.track.colour >> 4) << 1;
+    vehicle->track_type = (tileElement->properties.track.type << 2) | (direction & 3);
+    vehicle->var_CF     = (tileElement->properties.track.colour >> 4) << 1;
 
     // There are two bytes before the move info list
     regs.ax = vehicle_get_move_info_size(vehicle->var_CD, vehicle->track_type);
diff --git a/src/openrct2/ride/coaster/AirPoweredVerticalCoaster.cpp b/src/openrct2/ride/coaster/AirPoweredVerticalCoaster.cpp
index 1b656d0f41..a6f64878cb 100644
--- a/src/openrct2/ride/coaster/AirPoweredVerticalCoaster.cpp
+++ b/src/openrct2/ride/coaster/AirPoweredVerticalCoaster.cpp
@@ -182,7 +182,7 @@ static uint32 air_powered_vertical_rc_get_support_colour(paint_session * session
 
 /** rct2: 0x008AFAD4 */
 static void air_powered_vertical_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4] = {
         SPR_AIR_POWERED_VERTICAL_RC_FLAT_SW_NE,
@@ -203,7 +203,7 @@ static void air_powered_vertical_rc_track_flat(paint_session * session, uint8 ri
 }
 
 static void air_powered_vertical_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_AIR_POWERED_VERTICAL_RC_STATION_SW_NE, SPR_STATION_BASE_B_SW_NE },
@@ -220,7 +220,7 @@ static void air_powered_vertical_rc_track_station(paint_session * session, uint8
     wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
 
     Ride * ride = get_ride(rideIndex);
-    track_paint_util_draw_station_platform(session, ride, direction, height, 5, mapElement);
+    track_paint_util_draw_station_platform(session, ride, direction, height, 5, tileElement);
 
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
 
@@ -229,7 +229,7 @@ static void air_powered_vertical_rc_track_station(paint_session * session, uint8
 }
 
 static void air_powered_vertical_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][5] = {
         {
@@ -308,16 +308,16 @@ static void air_powered_vertical_rc_track_right_quarter_turn_5(paint_session * s
 }
 
 static void air_powered_vertical_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     air_powered_vertical_rc_track_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008AFB74 */
 static void air_powered_vertical_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_AIR_POWERED_VERTICAL_RC_FLAT_TO_LEFT_BANK_SW_NE, SPR_AIR_POWERED_VERTICAL_RC_FLAT_TO_LEFT_BANK_FRONT_SW_NE },
@@ -345,7 +345,7 @@ static void air_powered_vertical_rc_track_flat_to_left_bank(paint_session * sess
 
 /** rct2: 0x008AFB84 */
 static void air_powered_vertical_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_AIR_POWERED_VERTICAL_RC_FLAT_TO_RIGHT_BANK_SW_NE, SPR_AIR_POWERED_VERTICAL_RC_FLAT_TO_LEFT_BANK_FRONT_SW_NE },
@@ -372,22 +372,22 @@ static void air_powered_vertical_rc_track_flat_to_right_bank(paint_session * ses
 }
 
 static void air_powered_vertical_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     air_powered_vertical_rc_track_flat_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008AFBA4 */
 static void air_powered_vertical_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    air_powered_vertical_rc_track_flat_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    air_powered_vertical_rc_track_flat_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void air_powered_vertical_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][5] = {
         {
@@ -481,16 +481,16 @@ static void air_powered_vertical_rc_track_banked_right_quarter_turn_5(paint_sess
 
 static void air_powered_vertical_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     air_powered_vertical_rc_track_banked_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008AFBD4 */
 static void air_powered_vertical_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4] = {
         SPR_AIR_POWERED_VERTICAL_RC_LEFT_BANK_SW_NE,
@@ -518,13 +518,13 @@ static void air_powered_vertical_rc_track_left_bank(paint_session * session, uin
 }
 
 static void air_powered_vertical_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    air_powered_vertical_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    air_powered_vertical_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void air_powered_vertical_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4] = {
         SPR_AIR_POWERED_VERTICAL_RC_BRAKES_NW_SE,
@@ -545,7 +545,7 @@ static void air_powered_vertical_rc_track_brakes(paint_session * session, uint8
 }
 
 static void air_powered_vertical_rc_track_vertical_slope_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 trackImageIds[7][4] = {
         {
@@ -747,7 +747,7 @@ static void air_powered_vertical_rc_track_vertical_slope_up(paint_session * sess
 }
 
 static void air_powered_vertical_rc_track_vertical_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_AIR_POWERED_VERTICAL_RC_VERTICAL_UP_SW_NE_SEQ_0, SPR_AIR_POWERED_VERTICAL_RC_VERTICAL_UP_SW_NE_SEQ_1 },
@@ -783,12 +783,12 @@ static void air_powered_vertical_rc_track_vertical_up(paint_session * session, u
 }
 
 static void air_powered_vertical_rc_track_vertical_top(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
         air_powered_vertical_rc_track_vertical_top(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height,
-                                                   mapElement);
+                                                   tileElement);
         return;
     }
 
@@ -865,16 +865,16 @@ static void air_powered_vertical_rc_track_vertical_top(paint_session * session,
 }
 
 static void air_powered_vertical_rc_track_vertical_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    air_powered_vertical_rc_track_vertical_up(session, rideIndex, trackSequence ^ 1, (direction + 2) & 3, height, mapElement);
+    air_powered_vertical_rc_track_vertical_up(session, rideIndex, trackSequence ^ 1, (direction + 2) & 3, height, tileElement);
 }
 
 static void air_powered_vertical_rc_track_vertical_slope_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     air_powered_vertical_rc_track_vertical_slope_up(session, rideIndex, 6 - trackSequence, (direction + 2) & 3, height,
-                                                    mapElement);
+                                                    tileElement);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_air_powered_vertical_rc(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/coaster/BobsleighCoaster.cpp b/src/openrct2/ride/coaster/BobsleighCoaster.cpp
index 56dd545177..d684c8e129 100644
--- a/src/openrct2/ride/coaster/BobsleighCoaster.cpp
+++ b/src/openrct2/ride/coaster/BobsleighCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x006FE5B4 */
 static void bobsleigh_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -85,7 +85,7 @@ static void bobsleigh_rc_track_flat(paint_session * session, uint8 rideIndex, ui
 }
 
 static void bobsleigh_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { 14580, SPR_STATION_BASE_B_SW_NE },
@@ -99,7 +99,7 @@ static void bobsleigh_rc_track_station(paint_session * session, uint8 rideIndex,
     sub_98196C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -107,9 +107,9 @@ static void bobsleigh_rc_track_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x006FE5C4 */
 static void bobsleigh_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -192,9 +192,9 @@ static void bobsleigh_rc_track_25_deg_up(paint_session * session, uint8 rideInde
 
 /** rct2: 0x006FE5D4 */
 static void bobsleigh_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -277,9 +277,9 @@ static void bobsleigh_rc_track_flat_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x006FE5E4 */
 static void bobsleigh_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -362,28 +362,28 @@ static void bobsleigh_rc_track_25_deg_up_to_flat(paint_session * session, uint8
 
 /** rct2: 0x006FE5F4 */
 static void bobsleigh_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    bobsleigh_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    bobsleigh_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE604 */
 static void bobsleigh_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bobsleigh_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    bobsleigh_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE614 */
 static void bobsleigh_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bobsleigh_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    bobsleigh_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE624 */
 static void bobsleigh_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -577,15 +577,15 @@ static void bobsleigh_rc_track_left_quarter_turn_5(paint_session * session, uint
 
 /** rct2: 0x006FE634 */
 static void bobsleigh_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    bobsleigh_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    bobsleigh_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE644 */
 static void bobsleigh_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -626,7 +626,7 @@ static void bobsleigh_rc_track_flat_to_left_bank(paint_session * session, uint8
 
 /** rct2: 0x006FE654 */
 static void bobsleigh_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -667,7 +667,7 @@ static void bobsleigh_rc_track_flat_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x006FE664 */
 static void bobsleigh_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -708,7 +708,7 @@ static void bobsleigh_rc_track_left_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x006FE674 */
 static void bobsleigh_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -749,7 +749,7 @@ static void bobsleigh_rc_track_right_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x006FE684 */
 static void bobsleigh_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -943,15 +943,15 @@ static void bobsleigh_rc_track_banked_left_quarter_turn_5(paint_session * sessio
 
 /** rct2: 0x006FE694 */
 static void bobsleigh_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    bobsleigh_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    bobsleigh_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE6A4 */
 static void bobsleigh_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -999,7 +999,7 @@ static void bobsleigh_rc_track_left_bank_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x006FE6B4 */
 static void bobsleigh_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1047,7 +1047,7 @@ static void bobsleigh_rc_track_right_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x006FE6C4 */
 static void bobsleigh_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1095,7 +1095,7 @@ static void bobsleigh_rc_track_25_deg_up_to_left_bank(paint_session * session, u
 
 /** rct2: 0x006FE6D4 */
 static void bobsleigh_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1143,35 +1143,35 @@ static void bobsleigh_rc_track_25_deg_up_to_right_bank(paint_session * session,
 
 /** rct2: 0x006FE6E4 */
 static void bobsleigh_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bobsleigh_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    bobsleigh_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE6F4 */
 static void bobsleigh_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bobsleigh_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    bobsleigh_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE704 */
 static void bobsleigh_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bobsleigh_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    bobsleigh_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE714 */
 static void bobsleigh_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bobsleigh_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    bobsleigh_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE724 */
 static void bobsleigh_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1212,14 +1212,14 @@ static void bobsleigh_rc_track_left_bank(paint_session * session, uint8 rideInde
 
 /** rct2: 0x006FE734 */
 static void bobsleigh_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    bobsleigh_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    bobsleigh_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE744 */
 static void bobsleigh_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1379,7 +1379,7 @@ static void bobsleigh_rc_track_s_bend_left(paint_session * session, uint8 rideIn
 
 /** rct2: 0x006FE754 */
 static void bobsleigh_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1539,7 +1539,7 @@ static void bobsleigh_rc_track_s_bend_right(paint_session * session, uint8 rideI
 
 /** rct2: 0x006FE794 */
 static void bobsleigh_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1662,15 +1662,15 @@ static void bobsleigh_rc_track_left_quarter_turn_3(paint_session * session, uint
 
 /** rct2: 0x006FE7A4 */
 static void bobsleigh_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    bobsleigh_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    bobsleigh_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE7B4 */
 static void bobsleigh_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1793,15 +1793,15 @@ static void bobsleigh_rc_track_left_quarter_turn_3_bank(paint_session * session,
 
 /** rct2: 0x006FE7C4 */
 static void bobsleigh_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    bobsleigh_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    bobsleigh_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x006FE7D4 */
 static void bobsleigh_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2042,7 +2042,7 @@ static void bobsleigh_rc_track_left_half_banked_helix_up_small(paint_session * s
 
 /** rct2: 0x006FE7E4 */
 static void bobsleigh_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2283,7 +2283,7 @@ static void bobsleigh_rc_track_right_half_banked_helix_up_small(paint_session *
 
 /** rct2: 0x006FE7F4 */
 static void bobsleigh_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2292,12 +2292,12 @@ static void bobsleigh_rc_track_left_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bobsleigh_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x006FE804 */
 static void bobsleigh_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2306,12 +2306,12 @@ static void bobsleigh_rc_track_right_half_banked_helix_down_small(paint_session
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bobsleigh_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x006FE814 */
 static void bobsleigh_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2694,7 +2694,7 @@ static void bobsleigh_rc_track_left_half_banked_helix_up_large(paint_session * s
 
 /** rct2: 0x006FE824 */
 static void bobsleigh_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3077,7 +3077,7 @@ static void bobsleigh_rc_track_right_half_banked_helix_up_large(paint_session *
 
 /** rct2: 0x006FE834 */
 static void bobsleigh_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3086,12 +3086,12 @@ static void bobsleigh_rc_track_left_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bobsleigh_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x006FE844 */
 static void bobsleigh_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3100,12 +3100,12 @@ static void bobsleigh_rc_track_right_half_banked_helix_down_large(paint_session
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bobsleigh_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x006FE854 */
 static void bobsleigh_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3136,7 +3136,7 @@ static void bobsleigh_rc_track_brakes(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x006FE864 */
 static void bobsleigh_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3166,7 +3166,7 @@ static void bobsleigh_rc_track_block_brakes(paint_session * session, uint8 rideI
 }
 
 static void bobsleigh_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3209,7 +3209,7 @@ static void bobsleigh_rc_track_on_ride_photo(paint_session * session, uint8 ride
 
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
diff --git a/src/openrct2/ride/coaster/BolligerMabillardTrack.cpp b/src/openrct2/ride/coaster/BolligerMabillardTrack.cpp
index ef40069ec6..b5d65e2690 100644
--- a/src/openrct2/ride/coaster/BolligerMabillardTrack.cpp
+++ b/src/openrct2/ride/coaster/BolligerMabillardTrack.cpp
@@ -28,9 +28,9 @@
 #include "BolligerMabillardTrack.h"
 
 void bolliger_mabillard_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                   sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -83,7 +83,7 @@ void bolliger_mabillard_track_flat(paint_session * session, uint8 rideIndex, uin
 }
 
 void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                      sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     static const uint32 imageIds[4][3] = {
         { 17154, 17150, SPR_STATION_BASE_A_SW_NE },
@@ -92,7 +92,7 @@ void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex,
         { 17155, 17151, SPR_STATION_BASE_A_NW_SE },
     };
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20, 1,
                            height, 0, 6, height + 3);
@@ -108,7 +108,7 @@ void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex,
                                                    supportType);
 
     Ride * ride = get_ride(rideIndex);
-    track_paint_util_draw_station_platform(session, ride, direction, height, 9, mapElement);
+    track_paint_util_draw_station_platform(session, ride, direction, height, 9, tileElement);
 
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -116,9 +116,9 @@ void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex,
 }
 
 void bolliger_mabillard_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                        sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -184,9 +184,9 @@ void bolliger_mabillard_track_25_deg_up(paint_session * session, uint8 rideIndex
 }
 
 void bolliger_mabillard_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                        sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -252,9 +252,9 @@ void bolliger_mabillard_track_60_deg_up(paint_session * session, uint8 rideIndex
 }
 
 void bolliger_mabillard_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -320,10 +320,10 @@ void bolliger_mabillard_track_flat_to_25_deg_up(paint_session * session, uint8 r
 }
 
 void bolliger_mabillard_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -397,10 +397,10 @@ void bolliger_mabillard_track_25_deg_up_to_60_deg_up(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -474,9 +474,9 @@ void bolliger_mabillard_track_60_deg_up_to_25_deg_up(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -542,51 +542,51 @@ void bolliger_mabillard_track_25_deg_up_to_flat(paint_session * session, uint8 r
 }
 
 void bolliger_mabillard_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                          sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    bolliger_mabillard_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement, supportType);
+    bolliger_mabillard_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                          sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    bolliger_mabillard_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement, supportType);
+    bolliger_mabillard_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
-    bolliger_mabillard_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                supportType);
 }
 
 void bolliger_mabillard_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                          sint32 supportType)
 {
-    bolliger_mabillard_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                     supportType);
 }
 
 void bolliger_mabillard_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                          sint32 supportType)
 {
-    bolliger_mabillard_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                     supportType);
 }
 
 void bolliger_mabillard_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
-    bolliger_mabillard_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                supportType);
 }
 
 void bolliger_mabillard_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
     switch (trackSequence)
@@ -740,16 +740,16 @@ void bolliger_mabillard_track_left_quarter_turn_5(paint_session * session, uint8
 }
 
 void bolliger_mabillard_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                    sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    bolliger_mabillard_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement,
                                                  supportType);
 }
 
 void bolliger_mabillard_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -785,7 +785,7 @@ void bolliger_mabillard_track_flat_to_left_bank(paint_session * session, uint8 r
 }
 
 void bolliger_mabillard_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                 sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -821,7 +821,7 @@ void bolliger_mabillard_track_flat_to_right_bank(paint_session * session, uint8
 }
 
 void bolliger_mabillard_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -857,7 +857,7 @@ void bolliger_mabillard_track_left_bank_to_flat(paint_session * session, uint8 r
 }
 
 void bolliger_mabillard_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                 sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -893,7 +893,7 @@ void bolliger_mabillard_track_right_bank_to_flat(paint_session * session, uint8
 }
 
 void bolliger_mabillard_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                          sint32 supportType)
 {
     switch (trackSequence)
@@ -1054,16 +1054,16 @@ void bolliger_mabillard_track_banked_left_quarter_turn_5(paint_session * session
 }
 
 void bolliger_mabillard_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bolliger_mabillard_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                        mapElement, supportType);
+                                                        tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (direction)
@@ -1107,7 +1107,7 @@ void bolliger_mabillard_track_left_bank_to_25_deg_up(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                       sint32 supportType)
 {
     switch (direction)
@@ -1151,7 +1151,7 @@ void bolliger_mabillard_track_right_bank_to_25_deg_up(paint_session * session, u
 }
 
 void bolliger_mabillard_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (direction)
@@ -1195,7 +1195,7 @@ void bolliger_mabillard_track_25_deg_up_to_left_bank(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                       sint32 supportType)
 {
     switch (direction)
@@ -1239,39 +1239,39 @@ void bolliger_mabillard_track_25_deg_up_to_right_bank(paint_session * session, u
 }
 
 void bolliger_mabillard_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
-    bolliger_mabillard_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                      supportType);
 }
 
 void bolliger_mabillard_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                         sint32 supportType)
 {
-    bolliger_mabillard_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                     supportType);
 }
 
 void bolliger_mabillard_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
-    bolliger_mabillard_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                      supportType);
 }
 
 void bolliger_mabillard_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                         sint32 supportType)
 {
-    bolliger_mabillard_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                     supportType);
 }
 
 void bolliger_mabillard_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                        sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -1303,13 +1303,13 @@ void bolliger_mabillard_track_left_bank(paint_session * session, uint8 rideIndex
 }
 
 void bolliger_mabillard_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                         sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    bolliger_mabillard_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement, supportType);
+    bolliger_mabillard_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     switch (trackSequence)
@@ -1458,7 +1458,7 @@ void bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(paint_session * sess
 }
 
 void bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     switch (trackSequence)
@@ -1607,25 +1607,25 @@ void bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(paint_session * ses
 }
 
 void bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                            mapElement, supportType);
+                                                            tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                           mapElement, supportType);
+                                                           tileElement, supportType);
 }
 
 void bolliger_mabillard_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                          sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -1748,7 +1748,7 @@ void bolliger_mabillard_track_s_bend_left(paint_session * session, uint8 rideInd
 }
 
 void bolliger_mabillard_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                           sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -1871,7 +1871,7 @@ void bolliger_mabillard_track_s_bend_right(paint_session * session, uint8 rideIn
 }
 
 void bolliger_mabillard_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                 sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -2094,7 +2094,7 @@ void bolliger_mabillard_track_left_vertical_loop(paint_session * session, uint8
 }
 
 void bolliger_mabillard_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
     switch (trackSequence)
@@ -2286,7 +2286,7 @@ void bolliger_mabillard_track_right_vertical_loop(paint_session * session, uint8
 }
 
 void bolliger_mabillard_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
     switch (trackSequence)
@@ -2385,16 +2385,16 @@ void bolliger_mabillard_track_left_quarter_turn_3(paint_session * session, uint8
 }
 
 void bolliger_mabillard_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                    sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    bolliger_mabillard_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement,
                                                  supportType);
 }
 
 void bolliger_mabillard_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
     switch (trackSequence)
@@ -2497,16 +2497,16 @@ void bolliger_mabillard_track_left_quarter_turn_3_bank(paint_session * session,
 }
 
 void bolliger_mabillard_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                         sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bolliger_mabillard_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                      mapElement, supportType);
+                                                      tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     switch (trackSequence)
@@ -2576,7 +2576,7 @@ void bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(paint_session * sess
 }
 
 void bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     switch (trackSequence)
@@ -2649,25 +2649,25 @@ void bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(paint_session * ses
 }
 
 void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                            mapElement, supportType);
+                                                            tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                           mapElement, supportType);
+                                                           tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     switch (trackSequence)
@@ -2868,7 +2868,7 @@ void bolliger_mabillard_track_left_half_banked_helix_up_small(paint_session * se
 }
 
 void bolliger_mabillard_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                sint32 supportType)
 {
     switch (trackSequence)
@@ -3069,7 +3069,7 @@ void bolliger_mabillard_track_right_half_banked_helix_up_small(paint_session * s
 }
 
 void bolliger_mabillard_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                 sint32 supportType)
 {
     if (trackSequence >= 4)
@@ -3079,11 +3079,11 @@ void bolliger_mabillard_track_left_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bolliger_mabillard_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                              mapElement, supportType);
+                                                              tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                  sint32 supportType)
 {
     if (trackSequence >= 4)
@@ -3093,11 +3093,11 @@ void bolliger_mabillard_track_right_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bolliger_mabillard_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                             mapElement, supportType);
+                                                             tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     switch (trackSequence)
@@ -3408,7 +3408,7 @@ void bolliger_mabillard_track_left_half_banked_helix_up_large(paint_session * se
 }
 
 void bolliger_mabillard_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                sint32 supportType)
 {
     switch (trackSequence)
@@ -3725,7 +3725,7 @@ void bolliger_mabillard_track_right_half_banked_helix_up_large(paint_session * s
 }
 
 void bolliger_mabillard_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                 sint32 supportType)
 {
     if (trackSequence >= 7)
@@ -3735,11 +3735,11 @@ void bolliger_mabillard_track_left_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bolliger_mabillard_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                              mapElement, supportType);
+                                                              tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                  sint32 supportType)
 {
     if (trackSequence >= 7)
@@ -3749,11 +3749,11 @@ void bolliger_mabillard_track_right_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bolliger_mabillard_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                             mapElement, supportType);
+                                                             tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     switch (direction)
@@ -3789,7 +3789,7 @@ void bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(paint_session * sess
 }
 
 void bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     switch (direction)
@@ -3825,23 +3825,23 @@ void bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(paint_session * ses
 }
 
 void bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                            mapElement, supportType);
+                                                            tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                sint32 supportType)
 {
     bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                           mapElement, supportType);
+                                                           tileElement, supportType);
 }
 
 void bolliger_mabillard_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                     sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -3867,7 +3867,7 @@ void bolliger_mabillard_track_brakes(paint_session * session, uint8 rideIndex, u
 }
 
 void bolliger_mabillard_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                     sint32 supportType)
 {
     switch (direction)
@@ -3907,7 +3907,7 @@ void bolliger_mabillard_track_25_deg_up_left_banked(paint_session * session, uin
 }
 
 void bolliger_mabillard_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (direction)
@@ -3947,7 +3947,7 @@ void bolliger_mabillard_track_25_deg_up_right_banked(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                            sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -3980,30 +3980,30 @@ void bolliger_mabillard_track_on_ride_photo(paint_session * session, uint8 rideI
                            height + 3);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
 }
 
 void bolliger_mabillard_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                       sint32 supportType)
 {
-    bolliger_mabillard_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                     supportType);
 }
 
 void bolliger_mabillard_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
-    bolliger_mabillard_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                    supportType);
 }
 
 void bolliger_mabillard_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                        sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -4038,13 +4038,13 @@ void bolliger_mabillard_track_90_deg_up(paint_session * session, uint8 rideIndex
 }
 
 void bolliger_mabillard_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                          sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    bolliger_mabillard_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement, supportType);
+    bolliger_mabillard_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (trackSequence)
@@ -4084,15 +4084,15 @@ void bolliger_mabillard_track_60_deg_up_to_90_deg_up(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                          sint32 supportType)
 {
-    bolliger_mabillard_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                     supportType);
 }
 
 void bolliger_mabillard_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (direction)
@@ -4129,7 +4129,7 @@ void bolliger_mabillard_track_90_deg_up_to_60_deg_up(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                          sint32 supportType)
 {
     switch (trackSequence)
@@ -4168,7 +4168,7 @@ void bolliger_mabillard_track_60_deg_down_to_90_deg_down(paint_session * session
 }
 
 void bolliger_mabillard_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
     switch (trackSequence)
@@ -4292,7 +4292,7 @@ void bolliger_mabillard_track_left_eighth_to_diag(paint_session * session, uint8
 }
 
 void bolliger_mabillard_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                    sint32 supportType)
 {
     switch (trackSequence)
@@ -4416,25 +4416,25 @@ void bolliger_mabillard_track_right_eighth_to_diag(paint_session * session, uint
 }
 
 void bolliger_mabillard_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                         sint32 supportType)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    bolliger_mabillard_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                   supportType);
 }
 
 void bolliger_mabillard_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                          sint32 supportType)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    bolliger_mabillard_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement,
+    bolliger_mabillard_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement,
                                                  supportType);
 }
 
 void bolliger_mabillard_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
     switch (trackSequence)
@@ -4558,7 +4558,7 @@ void bolliger_mabillard_track_left_eighth_bank_to_diag(paint_session * session,
 }
 
 void bolliger_mabillard_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                         sint32 supportType)
 {
     switch (trackSequence)
@@ -4682,30 +4682,30 @@ void bolliger_mabillard_track_right_eighth_bank_to_diag(paint_session * session,
 }
 
 void bolliger_mabillard_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     bolliger_mabillard_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                       mapElement, supportType);
+                                                       tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     bolliger_mabillard_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height,
-                                                      mapElement, supportType);
+                                                      tileElement, supportType);
 }
 
 void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                        sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4730,7 +4730,7 @@ void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4755,7 +4755,7 @@ void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4780,7 +4780,7 @@ void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4828,12 +4828,12 @@ void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex
 }
 
 void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                             sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4858,7 +4858,7 @@ void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4883,7 +4883,7 @@ void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4908,7 +4908,7 @@ void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4956,12 +4956,12 @@ void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 ride
 }
 
 void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                             sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4986,7 +4986,7 @@ void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5011,7 +5011,7 @@ void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5036,7 +5036,7 @@ void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5084,13 +5084,13 @@ void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 ride
 }
 
 void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5115,7 +5115,7 @@ void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5140,7 +5140,7 @@ void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5165,7 +5165,7 @@ void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5213,13 +5213,13 @@ void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5244,7 +5244,7 @@ void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5269,7 +5269,7 @@ void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5294,7 +5294,7 @@ void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5342,13 +5342,13 @@ void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
 }
 
 void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5373,7 +5373,7 @@ void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5398,7 +5398,7 @@ void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5423,7 +5423,7 @@ void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5471,13 +5471,13 @@ void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
 }
 
 void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5502,7 +5502,7 @@ void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5527,7 +5527,7 @@ void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5552,7 +5552,7 @@ void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5600,12 +5600,12 @@ void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                               sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5630,7 +5630,7 @@ void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5655,7 +5655,7 @@ void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5680,7 +5680,7 @@ void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5728,12 +5728,12 @@ void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 ri
 }
 
 void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                               sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5758,7 +5758,7 @@ void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5783,7 +5783,7 @@ void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5808,7 +5808,7 @@ void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5856,13 +5856,13 @@ void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 ri
 }
 
 void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5886,7 +5886,7 @@ void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5910,7 +5910,7 @@ void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5934,7 +5934,7 @@ void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5983,13 +5983,13 @@ void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session,
 }
 
 void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6014,7 +6014,7 @@ void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6039,7 +6039,7 @@ void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6064,7 +6064,7 @@ void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6112,13 +6112,13 @@ void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * se
 }
 
 void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6143,7 +6143,7 @@ void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6168,7 +6168,7 @@ void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6193,7 +6193,7 @@ void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6241,13 +6241,13 @@ void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * se
 }
 
 void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6272,7 +6272,7 @@ void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6297,7 +6297,7 @@ void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6322,7 +6322,7 @@ void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6370,13 +6370,13 @@ void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session,
 }
 
 void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6401,7 +6401,7 @@ void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6426,7 +6426,7 @@ void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6451,7 +6451,7 @@ void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6499,13 +6499,13 @@ void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6530,7 +6530,7 @@ void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6555,7 +6555,7 @@ void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6580,7 +6580,7 @@ void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6628,13 +6628,13 @@ void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6659,7 +6659,7 @@ void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6684,7 +6684,7 @@ void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6709,7 +6709,7 @@ void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6757,13 +6757,13 @@ void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session,
 }
 
 void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6788,7 +6788,7 @@ void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6813,7 +6813,7 @@ void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6838,7 +6838,7 @@ void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6886,7 +6886,7 @@ void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session,
 }
 
 void bolliger_mabillard_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (trackSequence)
@@ -6955,7 +6955,7 @@ void bolliger_mabillard_track_diag_flat_to_left_bank(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                       sint32 supportType)
 {
     switch (trackSequence)
@@ -7024,7 +7024,7 @@ void bolliger_mabillard_track_diag_flat_to_right_bank(paint_session * session, u
 }
 
 void bolliger_mabillard_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                      sint32 supportType)
 {
     switch (trackSequence)
@@ -7093,7 +7093,7 @@ void bolliger_mabillard_track_diag_left_bank_to_flat(paint_session * session, ui
 }
 
 void bolliger_mabillard_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                       sint32 supportType)
 {
     switch (trackSequence)
@@ -7162,7 +7162,7 @@ void bolliger_mabillard_track_diag_right_bank_to_flat(paint_session * session, u
 }
 
 void bolliger_mabillard_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     switch (trackSequence)
@@ -7231,7 +7231,7 @@ void bolliger_mabillard_track_diag_left_bank_to_25_deg_up(paint_session * sessio
 }
 
 void bolliger_mabillard_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                            sint32 supportType)
 {
     switch (trackSequence)
@@ -7300,7 +7300,7 @@ void bolliger_mabillard_track_diag_right_bank_to_25_deg_up(paint_session * sessi
 }
 
 void bolliger_mabillard_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     switch (trackSequence)
@@ -7369,7 +7369,7 @@ void bolliger_mabillard_track_diag_25_deg_up_to_left_bank(paint_session * sessio
 }
 
 void bolliger_mabillard_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                            sint32 supportType)
 {
     switch (trackSequence)
@@ -7438,7 +7438,7 @@ void bolliger_mabillard_track_diag_25_deg_up_to_right_bank(paint_session * sessi
 }
 
 void bolliger_mabillard_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     switch (trackSequence)
@@ -7505,7 +7505,7 @@ void bolliger_mabillard_track_diag_left_bank_to_25_deg_down(paint_session * sess
 }
 
 void bolliger_mabillard_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     switch (trackSequence)
@@ -7572,7 +7572,7 @@ void bolliger_mabillard_track_diag_right_bank_to_25_deg_down(paint_session * ses
 }
 
 void bolliger_mabillard_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     switch (trackSequence)
@@ -7641,7 +7641,7 @@ void bolliger_mabillard_track_diag_25_deg_down_to_left_bank(paint_session * sess
 }
 
 void bolliger_mabillard_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     switch (trackSequence)
@@ -7710,7 +7710,7 @@ void bolliger_mabillard_track_diag_25_deg_down_to_right_bank(paint_session * ses
 }
 
 void bolliger_mabillard_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                             sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -7776,7 +7776,7 @@ void bolliger_mabillard_track_diag_left_bank(paint_session * session, uint8 ride
 }
 
 void bolliger_mabillard_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                              sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -7843,7 +7843,7 @@ void bolliger_mabillard_track_diag_right_bank(paint_session * session, uint8 rid
 
 void bolliger_mabillard_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement, sint32 supportType)
+                                                                         rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -7915,7 +7915,7 @@ void bolliger_mabillard_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_s
 
 void bolliger_mabillard_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement, sint32 supportType)
+                                                                           rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -7990,7 +7990,7 @@ void bolliger_mabillard_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint
 
 void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement, sint32 supportType)
+                                                                           rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -8065,7 +8065,7 @@ void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint
 
 void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex,
                                                                              uint8 trackSequence, uint8 direction,
-                                                                             sint32 height, rct_tile_element * mapElement,
+                                                                             sint32 height, rct_tile_element * tileElement,
                                                                              sint32 supportType)
 {
     switch (trackSequence)
@@ -8137,7 +8137,7 @@ void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down_to_right_bank(pai
 }
 
 void bolliger_mabillard_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                           sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -8164,7 +8164,7 @@ void bolliger_mabillard_track_block_brakes(paint_session * session, uint8 rideIn
 
 void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement, sint32 supportType)
+                                                                   rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -8237,7 +8237,7 @@ void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(paint_session
 
 void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement, sint32 supportType)
+                                                                    rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -8313,25 +8313,25 @@ void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(paint_sessio
 
 void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement, sint32 supportType)
+                                                                     rct_tile_element * tileElement, sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3,
-                                                                   height, mapElement, supportType);
+                                                                   height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement, sint32 supportType)
+                                                                      rct_tile_element * tileElement, sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3,
-                                                                  height, mapElement, supportType);
+                                                                  height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement, sint32 supportType)
+                                                                   rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -8483,7 +8483,7 @@ void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(paint_session
 
 void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement, sint32 supportType)
+                                                                    rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -8635,24 +8635,24 @@ void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(paint_sessio
 
 void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement, sint32 supportType)
+                                                                     rct_tile_element * tileElement, sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3,
-                                                                   height, mapElement, supportType);
+                                                                   height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement, sint32 supportType)
+                                                                      rct_tile_element * tileElement, sint32 supportType)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3,
-                                                                  height, mapElement, supportType);
+                                                                  height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                  sint32 supportType)
 {
     switch (direction)
@@ -8694,7 +8694,7 @@ void bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(paint_session *
 }
 
 void bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                   sint32 supportType)
 {
     switch (direction)
@@ -8736,7 +8736,7 @@ void bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(paint_session
 }
 
 void bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                  sint32 supportType)
 {
     switch (direction)
@@ -8778,7 +8778,7 @@ void bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(paint_session *
 }
 
 void bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                   sint32 supportType)
 {
     switch (direction)
@@ -8821,39 +8821,39 @@ void bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(paint_session
 
 void bolliger_mabillard_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement, sint32 supportType)
+                                                                     rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                 mapElement, supportType);
+                                                                 tileElement, supportType);
 }
 
 void bolliger_mabillard_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement, sint32 supportType)
+                                                                      rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                mapElement, supportType);
+                                                                tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement, sint32 supportType)
+                                                                     rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                 mapElement, supportType);
+                                                                 tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement, sint32 supportType)
+                                                                      rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                mapElement, supportType);
+                                                                tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement, sint32 supportType)
+                                                                        rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -8893,7 +8893,7 @@ void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(paint_se
 
 void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement, sint32 supportType)
+                                                                          rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -8933,7 +8933,7 @@ void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(paint_
 
 void bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement, sint32 supportType)
+                                                                        rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -8973,7 +8973,7 @@ void bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(paint_se
 
 void bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement, sint32 supportType)
+                                                                          rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -9013,38 +9013,38 @@ void bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(paint_
 
 void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement, sint32 supportType)
+                                                                          rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3,
-                                                                         height, mapElement, supportType);
+                                                                         height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                             uint8 trackSequence, uint8 direction, sint32 height,
-                                                                            rct_tile_element * mapElement, sint32 supportType)
+                                                                            rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3,
-                                                                       height, mapElement, supportType);
+                                                                       height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement, sint32 supportType)
+                                                                          rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3,
-                                                                         height, mapElement, supportType);
+                                                                         height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                             uint8 trackSequence, uint8 direction, sint32 height,
-                                                                            rct_tile_element * mapElement, sint32 supportType)
+                                                                            rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3,
-                                                                       height, mapElement, supportType);
+                                                                       height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     switch (direction)
@@ -9086,7 +9086,7 @@ void bolliger_mabillard_track_flat_to_left_banked_25_deg_up(paint_session * sess
 }
 
 void bolliger_mabillard_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     switch (direction)
@@ -9128,7 +9128,7 @@ void bolliger_mabillard_track_flat_to_right_banked_25_deg_up(paint_session * ses
 }
 
 void bolliger_mabillard_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     switch (direction)
@@ -9170,7 +9170,7 @@ void bolliger_mabillard_track_left_banked_25_deg_up_to_flat(paint_session * sess
 }
 
 void bolliger_mabillard_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     switch (direction)
@@ -9212,39 +9212,39 @@ void bolliger_mabillard_track_right_banked_25_deg_up_to_flat(paint_session * ses
 }
 
 void bolliger_mabillard_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     bolliger_mabillard_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                            mapElement, supportType);
+                                                            tileElement, supportType);
 }
 
 void bolliger_mabillard_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                sint32 supportType)
 {
     bolliger_mabillard_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                           mapElement, supportType);
+                                                           tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     bolliger_mabillard_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                            mapElement, supportType);
+                                                            tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                sint32 supportType)
 {
     bolliger_mabillard_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                           mapElement, supportType);
+                                                           tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     switch (trackSequence)
@@ -9284,7 +9284,7 @@ void bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(paint_session * sess
 }
 
 void bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     switch (trackSequence)
@@ -9324,26 +9324,26 @@ void bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(paint_session * ses
 }
 
 void bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                               sint32 supportType)
 {
     bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                            mapElement, supportType);
+                                                            tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                                sint32 supportType)
 {
     bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                           mapElement, supportType);
+                                                           tileElement, supportType);
 }
 
 /* The following track elements used to be specific to the Vertical Roller Coaster */
 void bolliger_mabillard_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -9411,9 +9411,9 @@ void bolliger_mabillard_track_flat_to_60_deg_up(paint_session * session, uint8 r
 }
 
 void bolliger_mabillard_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -9481,23 +9481,23 @@ void bolliger_mabillard_track_60_deg_up_to_flat(paint_session * session, uint8 r
 }
 
 void bolliger_mabillard_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
-    bolliger_mabillard_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                supportType);
 }
 
 void bolliger_mabillard_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
-    bolliger_mabillard_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement,
                                                supportType);
 }
 
 void bolliger_mabillard_track_brake_for_drop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                             sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -9538,7 +9538,7 @@ void bolliger_mabillard_track_brake_for_drop(paint_session * session, uint8 ride
 
 /* The following track elements used to be specific to the Steel Twister */
 void bolliger_mabillard_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                           sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -9645,13 +9645,13 @@ void bolliger_mabillard_track_half_loop_up(paint_session * session, uint8 rideIn
 }
 
 void bolliger_mabillard_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                             sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
-    bolliger_mabillard_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, mapElement, supportType);
+    bolliger_mabillard_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -9748,7 +9748,7 @@ void bolliger_mabillard_track_left_corkscrew_up(paint_session * session, uint8 r
 }
 
 void bolliger_mabillard_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                                 sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -9846,23 +9846,23 @@ void bolliger_mabillard_track_right_corkscrew_up(paint_session * session, uint8
 }
 
 void bolliger_mabillard_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                   sint32 supportType)
 {
-    bolliger_mabillard_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, mapElement,
+    bolliger_mabillard_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, tileElement,
                                                 supportType);
 }
 
 void bolliger_mabillard_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                    sint32 supportType)
 {
-    bolliger_mabillard_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, mapElement,
+    bolliger_mabillard_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement,
                                                supportType);
 }
 
 void bolliger_mabillard_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     switch (trackSequence)
@@ -9997,7 +9997,7 @@ void bolliger_mabillard_track_flat_to_60_deg_up_long_base(paint_session * sessio
 
 /** rct2: 0x008AC104 */
 void bolliger_mabillard_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     switch (trackSequence)
@@ -10131,23 +10131,23 @@ void bolliger_mabillard_track_60_deg_up_to_flat_long_base(paint_session * sessio
 }
 
 void bolliger_mabillard_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                             sint32 supportType)
 {
     bolliger_mabillard_track_flat_to_60_deg_up_long_base(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height,
-                                                         mapElement, supportType);
+                                                         tileElement, supportType);
 }
 
 void bolliger_mabillard_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                              sint32 supportType)
 {
     bolliger_mabillard_track_60_deg_up_to_flat_long_base(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height,
-                                                         mapElement, supportType);
+                                                         tileElement, supportType);
 }
 
 void bolliger_mabillard_track_left_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     switch (trackSequence)
@@ -10273,7 +10273,7 @@ void bolliger_mabillard_track_left_barrel_roll_up_to_down(paint_session * sessio
 }
 
 void bolliger_mabillard_track_right_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                            sint32 supportType)
 {
     switch (trackSequence)
@@ -10399,23 +10399,23 @@ void bolliger_mabillard_track_right_barrel_roll_up_to_down(paint_session * sessi
 }
 
 void bolliger_mabillard_track_left_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                           sint32 supportType)
 {
     bolliger_mabillard_track_left_barrel_roll_up_to_down(session, rideIndex, 2 - trackSequence, (direction + 2) & 3, height,
-                                                         mapElement, supportType);
+                                                         tileElement, supportType);
 }
 
 void bolliger_mabillard_track_right_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                            sint32 supportType)
 {
     bolliger_mabillard_track_right_barrel_roll_up_to_down(session, rideIndex, 2 - trackSequence, (direction + 2) & 3, height,
-                                                          mapElement, supportType);
+                                                          tileElement, supportType);
 }
 
 void bolliger_mabillard_track_powered_lift(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                           sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     switch (direction)
     {
@@ -10451,7 +10451,7 @@ void bolliger_mabillard_track_powered_lift(paint_session * session, uint8 rideIn
 }
 
 void bolliger_mabillard_track_left_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                       sint32 supportType)
 {
     switch (trackSequence)
@@ -10650,7 +10650,7 @@ void bolliger_mabillard_track_left_large_half_loop_up(paint_session * session, u
 }
 
 void bolliger_mabillard_track_right_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                        sint32 supportType)
 {
     switch (trackSequence)
@@ -10849,24 +10849,24 @@ void bolliger_mabillard_track_right_large_half_loop_up(paint_session * session,
 }
 
 void bolliger_mabillard_track_right_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                          sint32 supportType)
 {
-    bolliger_mabillard_track_right_large_half_loop_up(session, rideIndex, 6 - trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_large_half_loop_up(session, rideIndex, 6 - trackSequence, direction, height, tileElement,
                                                       supportType);
 }
 
 void bolliger_mabillard_track_left_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement,
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement,
                                                         sint32 supportType)
 {
-    bolliger_mabillard_track_left_large_half_loop_up(session, rideIndex, 6 - trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_large_half_loop_up(session, rideIndex, 6 - trackSequence, direction, height, tileElement,
                                                      supportType);
 }
 
 void bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement, sint32 supportType)
+                                                                      rct_tile_element * tileElement, sint32 supportType)
 {
     switch (trackSequence)
     {
@@ -10951,14 +10951,14 @@ void bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(paint_sess
 
 void bolliger_mabillard_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement, sint32 supportType)
+                                                                        rct_tile_element * tileElement, sint32 supportType)
 {
     bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(session, rideIndex, 2 - trackSequence, direction, height,
-                                                                     mapElement, supportType);
+                                                                     tileElement, supportType);
 }
 
 void bolliger_mabillard_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement, sint32 supportType)
+                                      sint32 height, rct_tile_element * tileElement, sint32 supportType)
 {
     // These offsets could be moved to the g2.dat file when that supports offsets.
     sint8 ne_sw_offsetX = 8;
diff --git a/src/openrct2/ride/coaster/BolligerMabillardTrack.h b/src/openrct2/ride/coaster/BolligerMabillardTrack.h
index 3d2cbb5f22..9f24fbe335 100644
--- a/src/openrct2/ride/coaster/BolligerMabillardTrack.h
+++ b/src/openrct2/ride/coaster/BolligerMabillardTrack.h
@@ -14,187 +14,187 @@
  *****************************************************************************/
 #pragma endregion
 
-void bolliger_mabillard_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
+void bolliger_mabillard_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
 
 /* Previously specific to the Vertical RC */
-void bolliger_mabillard_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_brake_for_drop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_brake_for_drop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
 
 /* Previously specific to the Steel Twister */
-void bolliger_mabillard_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_powered_lift(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_right_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_left_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
-void bolliger_mabillard_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
+void bolliger_mabillard_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_powered_lift(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_right_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_left_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
+void bolliger_mabillard_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
 
-void bolliger_mabillard_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, sint32 supportType);
+void bolliger_mabillard_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, sint32 supportType);
diff --git a/src/openrct2/ride/coaster/CompactInvertedCoaster.cpp b/src/openrct2/ride/coaster/CompactInvertedCoaster.cpp
index 266298b744..a96bf20f1c 100644
--- a/src/openrct2/ride/coaster/CompactInvertedCoaster.cpp
+++ b/src/openrct2/ride/coaster/CompactInvertedCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008AE6E0 */
 static void compact_inverted_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -77,7 +77,7 @@ static void compact_inverted_rc_track_flat(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008AE950, 0x008AE960, 0x008AE970 */
 static void compact_inverted_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_STATION_BASE_C_SW_NE, 26557, SPR_STATION_INVERTED_BAR_A_SW_NE },
@@ -93,7 +93,7 @@ static void compact_inverted_rc_track_station(paint_session * session, uint8 rid
     sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 3,
                        height + 29, 0, 6, height + 29);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
-    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
+    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
                                            STATION_VARIANT_TALL);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -102,9 +102,9 @@ static void compact_inverted_rc_track_station(paint_session * session, uint8 rid
 
 /** rct2: 0x008AE6F0 */
 static void compact_inverted_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -187,9 +187,9 @@ static void compact_inverted_rc_track_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008AE700 */
 static void compact_inverted_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -248,9 +248,9 @@ static void compact_inverted_rc_track_60_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008AE710 */
 static void compact_inverted_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -333,9 +333,9 @@ static void compact_inverted_rc_track_flat_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008AE720 */
 static void compact_inverted_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -402,9 +402,9 @@ static void compact_inverted_rc_track_25_deg_up_to_60_deg_up(paint_session * ses
 
 /** rct2: 0x008AE730 */
 static void compact_inverted_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -495,9 +495,9 @@ static void compact_inverted_rc_track_60_deg_up_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x008AE740 */
 static void compact_inverted_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -580,51 +580,51 @@ static void compact_inverted_rc_track_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x008AE750 */
 static void compact_inverted_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    compact_inverted_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    compact_inverted_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AE760 */
 static void compact_inverted_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    compact_inverted_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    compact_inverted_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AE770 */
 static void compact_inverted_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    compact_inverted_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    compact_inverted_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AE780 */
 static void compact_inverted_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008AE790 */
 static void compact_inverted_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008AE7A0 */
 static void compact_inverted_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    compact_inverted_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    compact_inverted_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AE7B0 */
 static void compact_inverted_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -781,15 +781,15 @@ static void compact_inverted_rc_track_left_quarter_turn_5(paint_session * sessio
 
 /** rct2: 0x008AE7C0 */
 static void compact_inverted_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    compact_inverted_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    compact_inverted_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AE7D0 */
 static void compact_inverted_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -827,7 +827,7 @@ static void compact_inverted_rc_track_flat_to_left_bank(paint_session * session,
 
 /** rct2: 0x008AE7E0 */
 static void compact_inverted_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -865,7 +865,7 @@ static void compact_inverted_rc_track_flat_to_right_bank(paint_session * session
 
 /** rct2: 0x008AE7F0 */
 static void compact_inverted_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -903,7 +903,7 @@ static void compact_inverted_rc_track_left_bank_to_flat(paint_session * session,
 
 /** rct2: 0x008AE800 */
 static void compact_inverted_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -941,7 +941,7 @@ static void compact_inverted_rc_track_right_bank_to_flat(paint_session * session
 
 /** rct2: 0x008AE810 */
 static void compact_inverted_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1098,16 +1098,16 @@ static void compact_inverted_rc_track_banked_left_quarter_turn_5(paint_session *
 
 /** rct2: 0x008AE820 */
 static void compact_inverted_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     compact_inverted_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x008AE830 */
 static void compact_inverted_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1169,7 +1169,7 @@ static void compact_inverted_rc_track_left_bank_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x008AE840 */
 static void compact_inverted_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1231,7 +1231,7 @@ static void compact_inverted_rc_track_right_bank_to_25_deg_up(paint_session * se
 
 /** rct2: 0x008AE850 */
 static void compact_inverted_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1293,7 +1293,7 @@ static void compact_inverted_rc_track_25_deg_up_to_left_bank(paint_session * ses
 
 /** rct2: 0x008AE860 */
 static void compact_inverted_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1355,39 +1355,39 @@ static void compact_inverted_rc_track_25_deg_up_to_right_bank(paint_session * se
 
 /** rct2: 0x008AE870 */
 static void compact_inverted_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008AE880 */
 static void compact_inverted_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008AE890 */
 static void compact_inverted_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008AE8A0 */
 static void compact_inverted_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008AE8B0 */
 static void compact_inverted_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1425,15 +1425,15 @@ static void compact_inverted_rc_track_left_bank(paint_session * session, uint8 r
 
 /** rct2: 0x008AE8C0 */
 static void compact_inverted_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    compact_inverted_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    compact_inverted_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AE8D0 */
 static void compact_inverted_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1576,7 +1576,7 @@ static void compact_inverted_rc_track_left_quarter_turn_5_25_deg_up(paint_sessio
 /** rct2: 0x008AE8E0 */
 static void compact_inverted_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1719,26 +1719,26 @@ static void compact_inverted_rc_track_right_quarter_turn_5_25_deg_up(paint_sessi
 /** rct2: 0x008AE8F0 */
 static void compact_inverted_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     compact_inverted_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x008AE900 */
 static void compact_inverted_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     compact_inverted_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008AE910 */
 static void compact_inverted_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1890,7 +1890,7 @@ static void compact_inverted_rc_track_s_bend_left(paint_session * session, uint8
 
 /** rct2: 0x008AE920 */
 static void compact_inverted_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2042,7 +2042,7 @@ static void compact_inverted_rc_track_s_bend_right(paint_session * session, uint
 
 /** rct2: 0x008AE930 */
 static void compact_inverted_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2312,7 +2312,7 @@ static void compact_inverted_rc_track_left_vertical_loop(paint_session * session
 
 /** rct2: 0x008AE940 */
 static void compact_inverted_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2582,7 +2582,7 @@ static void compact_inverted_rc_track_right_vertical_loop(paint_session * sessio
 
 /** rct2: 0x008AE980 */
 static void compact_inverted_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2688,15 +2688,15 @@ static void compact_inverted_rc_track_left_quarter_turn_3(paint_session * sessio
 
 /** rct2: 0x008AE990 */
 static void compact_inverted_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    compact_inverted_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    compact_inverted_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AE9A0 */
 static void compact_inverted_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2803,17 +2803,17 @@ static void compact_inverted_rc_track_left_quarter_turn_3_bank(paint_session * s
 
 /** rct2: 0x008AE9B0 */
 static void compact_inverted_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     compact_inverted_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008AE9C0 */
 static void compact_inverted_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2892,7 +2892,7 @@ static void compact_inverted_rc_track_left_quarter_turn_3_25_deg_up(paint_sessio
 /** rct2: 0x008AE9D0 */
 static void compact_inverted_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2971,26 +2971,26 @@ static void compact_inverted_rc_track_right_quarter_turn_3_25_deg_up(paint_sessi
 /** rct2: 0x008AE9E0 */
 static void compact_inverted_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     compact_inverted_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x008AE9F0 */
 static void compact_inverted_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     compact_inverted_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008AEA00 */
 static void compact_inverted_rc_track_left_twist_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3084,7 +3084,7 @@ static void compact_inverted_rc_track_left_twist_down_to_up(paint_session * sess
 
 /** rct2: 0x008AEA10 */
 static void compact_inverted_rc_track_right_twist_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3178,7 +3178,7 @@ static void compact_inverted_rc_track_right_twist_down_to_up(paint_session * ses
 
 /** rct2: 0x008AEA20 */
 static void compact_inverted_rc_track_left_twist_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3272,7 +3272,7 @@ static void compact_inverted_rc_track_left_twist_up_to_down(paint_session * sess
 
 /** rct2: 0x008AEA30 */
 static void compact_inverted_rc_track_right_twist_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3366,7 +3366,7 @@ static void compact_inverted_rc_track_right_twist_up_to_down(paint_session * ses
 
 /** rct2: 0x008AEA40 */
 static void compact_inverted_rc_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3501,14 +3501,14 @@ static void compact_inverted_rc_track_half_loop_up(paint_session * session, uint
 
 /** rct2: 0x008AEA50 */
 static void compact_inverted_rc_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    compact_inverted_rc_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, mapElement);
+    compact_inverted_rc_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, tileElement);
 }
 
 /** rct2: 0x008AEA60 */
 static void compact_inverted_rc_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3613,7 +3613,7 @@ static void compact_inverted_rc_track_left_corkscrew_up(paint_session * session,
 
 /** rct2: 0x008AEA70 */
 static void compact_inverted_rc_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3718,23 +3718,23 @@ static void compact_inverted_rc_track_right_corkscrew_up(paint_session * session
 
 /** rct2: 0x008AEA80 */
 static void compact_inverted_rc_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height,
-                                                 mapElement);
+                                                 tileElement);
 }
 
 /** rct2: 0x008AEA90 */
 static void compact_inverted_rc_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    compact_inverted_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, mapElement);
+    compact_inverted_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AEAD0 */
 static void compact_inverted_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3771,7 +3771,7 @@ static void compact_inverted_rc_track_left_quarter_turn_1_60_deg_up(paint_sessio
 /** rct2: 0x008AEAB0 */
 static void compact_inverted_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3808,24 +3808,24 @@ static void compact_inverted_rc_track_right_quarter_turn_1_60_deg_up(paint_sessi
 /** rct2: 0x008AEAC0 */
 static void compact_inverted_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x008AEAE0 */
 static void compact_inverted_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008AEAA0 */
 static void compact_inverted_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3856,7 +3856,7 @@ static void compact_inverted_rc_track_brakes(paint_session * session, uint8 ride
 /** rct2: 0x008AEAF0 */
 static void compact_inverted_rc_track_left_quarter_banked_helix_large_up(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4019,7 +4019,7 @@ static void compact_inverted_rc_track_left_quarter_banked_helix_large_up(paint_s
 /** rct2: 0x008AEB00 */
 static void compact_inverted_rc_track_right_quarter_banked_helix_large_up(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4182,7 +4182,7 @@ static void compact_inverted_rc_track_right_quarter_banked_helix_large_up(paint_
 /** rct2: 0x008AEB10 */
 static void compact_inverted_rc_track_left_quarter_banked_helix_large_down(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4345,7 +4345,7 @@ static void compact_inverted_rc_track_left_quarter_banked_helix_large_down(paint
 /** rct2: 0x008AEB20 */
 static void compact_inverted_rc_track_right_quarter_banked_helix_large_down(paint_session * session, uint8 rideIndex,
                                                                             uint8 trackSequence, uint8 direction, sint32 height,
-                                                                            rct_tile_element * mapElement)
+                                                                            rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4507,7 +4507,7 @@ static void compact_inverted_rc_track_right_quarter_banked_helix_large_down(pain
 
 /** rct2: 0x008AEB30 */
 static void compact_inverted_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4548,7 +4548,7 @@ static void compact_inverted_rc_track_on_ride_photo(paint_session * session, uin
                            height + 29);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_3);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 64, 0x20);
@@ -4556,12 +4556,12 @@ static void compact_inverted_rc_track_on_ride_photo(paint_session * session, uin
 
 /** rct2: 0x008AEDB0 */
 static void compact_inverted_rc_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4617,19 +4617,19 @@ static void compact_inverted_rc_track_90_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008AEDC0 */
 static void compact_inverted_rc_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    compact_inverted_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    compact_inverted_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AED70 */
 static void compact_inverted_rc_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4689,17 +4689,17 @@ static void compact_inverted_rc_track_60_deg_up_to_90_deg_up(paint_session * ses
 
 /** rct2: 0x008AED80 */
 static void compact_inverted_rc_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     compact_inverted_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008AED90 */
 static void compact_inverted_rc_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -4759,12 +4759,12 @@ static void compact_inverted_rc_track_90_deg_up_to_60_deg_up(paint_session * ses
 
 /** rct2: 0x008AEDA0 */
 static void compact_inverted_rc_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4823,7 +4823,7 @@ static void compact_inverted_rc_track_60_deg_down_to_90_deg_down(paint_session *
 
 /** rct2: 0x008AEB40 */
 static void compact_inverted_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4967,7 +4967,7 @@ static void compact_inverted_rc_track_left_eighth_to_diag(paint_session * sessio
 
 /** rct2: 0x008AEB50 */
 static void compact_inverted_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5111,23 +5111,23 @@ static void compact_inverted_rc_track_right_eighth_to_diag(paint_session * sessi
 
 /** rct2: 0x008AEB60 */
 static void compact_inverted_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    compact_inverted_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    compact_inverted_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AEB70 */
 static void compact_inverted_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    compact_inverted_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    compact_inverted_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AED30 */
 static void compact_inverted_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5272,7 +5272,7 @@ static void compact_inverted_rc_track_left_eighth_bank_to_diag(paint_session * s
 
 /** rct2: 0x008AED40 */
 static void compact_inverted_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5418,31 +5418,31 @@ static void compact_inverted_rc_track_right_eighth_bank_to_diag(paint_session *
 /** rct2: 0x008AED50 */
 static void compact_inverted_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     compact_inverted_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008AED60 */
 static void compact_inverted_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     compact_inverted_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008AEB80 */
 static void compact_inverted_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5467,7 +5467,7 @@ static void compact_inverted_rc_track_diag_flat(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5492,7 +5492,7 @@ static void compact_inverted_rc_track_diag_flat(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5517,7 +5517,7 @@ static void compact_inverted_rc_track_diag_flat(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5567,12 +5567,12 @@ static void compact_inverted_rc_track_diag_flat(paint_session * session, uint8 r
 
 /** rct2: 0x008AEBB0 */
 static void compact_inverted_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5597,7 +5597,7 @@ static void compact_inverted_rc_track_diag_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5622,7 +5622,7 @@ static void compact_inverted_rc_track_diag_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5647,7 +5647,7 @@ static void compact_inverted_rc_track_diag_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5697,7 +5697,7 @@ static void compact_inverted_rc_track_diag_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x008AEC10 */
 static void compact_inverted_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5775,12 +5775,12 @@ static void compact_inverted_rc_track_diag_60_deg_up(paint_session * session, ui
 
 /** rct2: 0x008AEB90 */
 static void compact_inverted_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5805,7 +5805,7 @@ static void compact_inverted_rc_track_diag_flat_to_25_deg_up(paint_session * ses
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5830,7 +5830,7 @@ static void compact_inverted_rc_track_diag_flat_to_25_deg_up(paint_session * ses
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5855,7 +5855,7 @@ static void compact_inverted_rc_track_diag_flat_to_25_deg_up(paint_session * ses
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5905,7 +5905,7 @@ static void compact_inverted_rc_track_diag_flat_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x008AEBF0 */
 static void compact_inverted_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5983,7 +5983,7 @@ static void compact_inverted_rc_track_diag_25_deg_up_to_60_deg_up(paint_session
 
 /** rct2: 0x008AEC00 */
 static void compact_inverted_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6061,12 +6061,12 @@ static void compact_inverted_rc_track_diag_60_deg_up_to_25_deg_up(paint_session
 
 /** rct2: 0x008AEBA0 */
 static void compact_inverted_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6091,7 +6091,7 @@ static void compact_inverted_rc_track_diag_25_deg_up_to_flat(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6116,7 +6116,7 @@ static void compact_inverted_rc_track_diag_25_deg_up_to_flat(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6141,7 +6141,7 @@ static void compact_inverted_rc_track_diag_25_deg_up_to_flat(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6191,12 +6191,12 @@ static void compact_inverted_rc_track_diag_25_deg_up_to_flat(paint_session * ses
 
 /** rct2: 0x008AEBE0 */
 static void compact_inverted_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6221,7 +6221,7 @@ static void compact_inverted_rc_track_diag_25_deg_down(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6246,7 +6246,7 @@ static void compact_inverted_rc_track_diag_25_deg_down(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6271,7 +6271,7 @@ static void compact_inverted_rc_track_diag_25_deg_down(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6321,7 +6321,7 @@ static void compact_inverted_rc_track_diag_25_deg_down(paint_session * session,
 
 /** rct2: 0x008AEC40 */
 static void compact_inverted_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6399,12 +6399,12 @@ static void compact_inverted_rc_track_diag_60_deg_down(paint_session * session,
 
 /** rct2: 0x008AEBC0 */
 static void compact_inverted_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6428,7 +6428,7 @@ static void compact_inverted_rc_track_diag_flat_to_25_deg_down(paint_session * s
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6452,7 +6452,7 @@ static void compact_inverted_rc_track_diag_flat_to_25_deg_down(paint_session * s
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6476,7 +6476,7 @@ static void compact_inverted_rc_track_diag_flat_to_25_deg_down(paint_session * s
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6527,7 +6527,7 @@ static void compact_inverted_rc_track_diag_flat_to_25_deg_down(paint_session * s
 /** rct2: 0x008AEC20 */
 static void compact_inverted_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6606,7 +6606,7 @@ static void compact_inverted_rc_track_diag_25_deg_down_to_60_deg_down(paint_sess
 /** rct2: 0x008AEC30 */
 static void compact_inverted_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6684,12 +6684,12 @@ static void compact_inverted_rc_track_diag_60_deg_down_to_25_deg_down(paint_sess
 
 /** rct2: 0x008AEBD0 */
 static void compact_inverted_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6714,7 +6714,7 @@ static void compact_inverted_rc_track_diag_25_deg_down_to_flat(paint_session * s
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6739,7 +6739,7 @@ static void compact_inverted_rc_track_diag_25_deg_down_to_flat(paint_session * s
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6764,7 +6764,7 @@ static void compact_inverted_rc_track_diag_25_deg_down_to_flat(paint_session * s
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6814,7 +6814,7 @@ static void compact_inverted_rc_track_diag_25_deg_down_to_flat(paint_session * s
 
 /** rct2: 0x008AEC70 */
 static void compact_inverted_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6893,7 +6893,7 @@ static void compact_inverted_rc_track_diag_flat_to_left_bank(paint_session * ses
 
 /** rct2: 0x008AEC80 */
 static void compact_inverted_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6972,7 +6972,7 @@ static void compact_inverted_rc_track_diag_flat_to_right_bank(paint_session * se
 
 /** rct2: 0x008AEC90 */
 static void compact_inverted_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7051,7 +7051,7 @@ static void compact_inverted_rc_track_diag_left_bank_to_flat(paint_session * ses
 
 /** rct2: 0x008AECA0 */
 static void compact_inverted_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7130,7 +7130,7 @@ static void compact_inverted_rc_track_diag_right_bank_to_flat(paint_session * se
 
 /** rct2: 0x008AECD0 */
 static void compact_inverted_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7209,7 +7209,7 @@ static void compact_inverted_rc_track_diag_left_bank_to_25_deg_up(paint_session
 /** rct2: 0x008AECE0 */
 static void compact_inverted_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7287,7 +7287,7 @@ static void compact_inverted_rc_track_diag_right_bank_to_25_deg_up(paint_session
 
 /** rct2: 0x008AECB0 */
 static void compact_inverted_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7366,7 +7366,7 @@ static void compact_inverted_rc_track_diag_25_deg_up_to_left_bank(paint_session
 /** rct2: 0x008AECC0 */
 static void compact_inverted_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7445,7 +7445,7 @@ static void compact_inverted_rc_track_diag_25_deg_up_to_right_bank(paint_session
 /** rct2: 0x008AECF0 */
 static void compact_inverted_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7521,7 +7521,7 @@ static void compact_inverted_rc_track_diag_left_bank_to_25_deg_down(paint_sessio
 /** rct2: 0x008AED00 */
 static void compact_inverted_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7597,7 +7597,7 @@ static void compact_inverted_rc_track_diag_right_bank_to_25_deg_down(paint_sessi
 /** rct2: 0x008AED10 */
 static void compact_inverted_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7676,7 +7676,7 @@ static void compact_inverted_rc_track_diag_25_deg_down_to_left_bank(paint_sessio
 /** rct2: 0x008AED20 */
 static void compact_inverted_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7754,7 +7754,7 @@ static void compact_inverted_rc_track_diag_25_deg_down_to_right_bank(paint_sessi
 
 /** rct2: 0x008AEC50 */
 static void compact_inverted_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7833,7 +7833,7 @@ static void compact_inverted_rc_track_diag_left_bank(paint_session * session, ui
 
 /** rct2: 0x008AEC60 */
 static void compact_inverted_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7912,7 +7912,7 @@ static void compact_inverted_rc_track_diag_right_bank(paint_session * session, u
 
 /** rct2: 0x008AEAA0 */
 static void compact_inverted_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
diff --git a/src/openrct2/ride/coaster/CorkscrewRollerCoaster.cpp b/src/openrct2/ride/coaster/CorkscrewRollerCoaster.cpp
index 1b47a68036..1049bbfdb0 100644
--- a/src/openrct2/ride/coaster/CorkscrewRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/CorkscrewRollerCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008A7AF8 */
 static void corkscrew_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -84,7 +84,7 @@ static void corkscrew_rc_track_flat(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008A7D68, 0x008A7D78, 0x008A7D88 */
 static void corkscrew_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 16236, 16232, SPR_STATION_BASE_A_SW_NE },
@@ -93,7 +93,7 @@ static void corkscrew_rc_track_station(paint_session * session, uint8 rideIndex,
         { 16237, 16233, SPR_STATION_BASE_A_NW_SE },
     };
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20, 1,
                            height, 0, 6, height + 3);
@@ -106,7 +106,7 @@ static void corkscrew_rc_track_station(paint_session * session, uint8 rideIndex,
     sub_98196C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -114,9 +114,9 @@ static void corkscrew_rc_track_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A7B08 */
 static void corkscrew_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -183,9 +183,9 @@ static void corkscrew_rc_track_25_deg_up(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A7B18 */
 static void corkscrew_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -252,9 +252,9 @@ static void corkscrew_rc_track_60_deg_up(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A7B28 */
 static void corkscrew_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -321,9 +321,9 @@ static void corkscrew_rc_track_flat_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A7B38 */
 static void corkscrew_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -398,9 +398,9 @@ static void corkscrew_rc_track_25_deg_up_to_60_deg_up(paint_session * session, u
 
 /** rct2: 0x008A7B48 */
 static void corkscrew_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -475,9 +475,9 @@ static void corkscrew_rc_track_60_deg_up_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A7B58 */
 static void corkscrew_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -544,49 +544,49 @@ static void corkscrew_rc_track_25_deg_up_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A7B68 */
 static void corkscrew_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7B78 */
 static void corkscrew_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7B88 */
 static void corkscrew_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7B98 */
 static void corkscrew_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7BA8 */
 static void corkscrew_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7BB8 */
 static void corkscrew_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7BC8 */
 static void corkscrew_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -740,15 +740,15 @@ static void corkscrew_rc_track_left_quarter_turn_5(paint_session * session, uint
 
 /** rct2: 0x008A7BD8 */
 static void corkscrew_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    corkscrew_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    corkscrew_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7BE8 */
 static void corkscrew_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -785,7 +785,7 @@ static void corkscrew_rc_track_flat_to_left_bank(paint_session * session, uint8
 
 /** rct2: 0x008A7BF8 */
 static void corkscrew_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -822,7 +822,7 @@ static void corkscrew_rc_track_flat_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x008A7C08 */
 static void corkscrew_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -859,7 +859,7 @@ static void corkscrew_rc_track_left_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A7C18 */
 static void corkscrew_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -896,7 +896,7 @@ static void corkscrew_rc_track_right_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A7C28 */
 static void corkscrew_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1054,15 +1054,15 @@ static void corkscrew_rc_track_banked_left_quarter_turn_5(paint_session * sessio
 
 /** rct2: 0x008A7C38 */
 static void corkscrew_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    corkscrew_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    corkscrew_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7C48 */
 static void corkscrew_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1106,7 +1106,7 @@ static void corkscrew_rc_track_left_bank_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A7C58 */
 static void corkscrew_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1150,7 +1150,7 @@ static void corkscrew_rc_track_right_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008A7C68 */
 static void corkscrew_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1194,7 +1194,7 @@ static void corkscrew_rc_track_25_deg_up_to_left_bank(paint_session * session, u
 
 /** rct2: 0x008A7C78 */
 static void corkscrew_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1238,35 +1238,35 @@ static void corkscrew_rc_track_25_deg_up_to_right_bank(paint_session * session,
 
 /** rct2: 0x008A7C88 */
 static void corkscrew_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7C98 */
 static void corkscrew_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7CA8 */
 static void corkscrew_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7CB8 */
 static void corkscrew_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7CC8 */
 static void corkscrew_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1299,14 +1299,14 @@ static void corkscrew_rc_track_left_bank(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A7CD8 */
 static void corkscrew_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7CE8 */
 static void corkscrew_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1455,7 +1455,7 @@ static void corkscrew_rc_track_left_quarter_turn_5_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A7CF8 */
 static void corkscrew_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1604,25 +1604,25 @@ static void corkscrew_rc_track_right_quarter_turn_5_25_deg_up(paint_session * se
 
 /** rct2: 0x008A7D08 */
 static void corkscrew_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     corkscrew_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A7D18 */
 static void corkscrew_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     corkscrew_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A7D28 */
 static void corkscrew_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1746,7 +1746,7 @@ static void corkscrew_rc_track_s_bend_left(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A7D38 */
 static void corkscrew_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1870,7 +1870,7 @@ static void corkscrew_rc_track_s_bend_right(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A7D48 */
 static void corkscrew_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2094,7 +2094,7 @@ static void corkscrew_rc_track_left_vertical_loop(paint_session * session, uint8
 
 /** rct2: 0x008A7D58 */
 static void corkscrew_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2286,7 +2286,7 @@ static void corkscrew_rc_track_right_vertical_loop(paint_session * session, uint
 
 /** rct2: 0x008A7D98 */
 static void corkscrew_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2385,15 +2385,15 @@ static void corkscrew_rc_track_left_quarter_turn_3(paint_session * session, uint
 
 /** rct2: 0x008A7DA8 */
 static void corkscrew_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    corkscrew_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    corkscrew_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7DB8 */
 static void corkscrew_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2496,15 +2496,15 @@ static void corkscrew_rc_track_left_quarter_turn_3_bank(paint_session * session,
 
 /** rct2: 0x008A7DC8 */
 static void corkscrew_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    corkscrew_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    corkscrew_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7DD8 */
 static void corkscrew_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2574,7 +2574,7 @@ static void corkscrew_rc_track_left_quarter_turn_3_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A7DE8 */
 static void corkscrew_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2647,25 +2647,25 @@ static void corkscrew_rc_track_right_quarter_turn_3_25_deg_up(paint_session * se
 
 /** rct2: 0x008A7DF8 */
 static void corkscrew_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     corkscrew_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A7E08 */
 static void corkscrew_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     corkscrew_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A7E18 */
 static void corkscrew_rc_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2773,14 +2773,14 @@ static void corkscrew_rc_track_half_loop_up(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A7E28 */
 static void corkscrew_rc_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, mapElement);
+    corkscrew_rc_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, tileElement);
 }
 
 /** rct2: 0x008A7E38 */
 static void corkscrew_rc_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2878,7 +2878,7 @@ static void corkscrew_rc_track_left_corkscrew_up(paint_session * session, uint8
 
 /** rct2: 0x008A7E48 */
 static void corkscrew_rc_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2977,21 +2977,21 @@ static void corkscrew_rc_track_right_corkscrew_up(paint_session * session, uint8
 
 /** rct2: 0x008A7E58 */
 static void corkscrew_rc_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, mapElement);
+    corkscrew_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7E68 */
 static void corkscrew_rc_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    corkscrew_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, mapElement);
+    corkscrew_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7E78 */
 static void corkscrew_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3192,7 +3192,7 @@ static void corkscrew_rc_track_left_half_banked_helix_up_small(paint_session * s
 
 /** rct2: 0x008A7E88 */
 static void corkscrew_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3393,7 +3393,7 @@ static void corkscrew_rc_track_right_half_banked_helix_up_small(paint_session *
 
 /** rct2: 0x008A7E98 */
 static void corkscrew_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -3402,12 +3402,12 @@ static void corkscrew_rc_track_left_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     corkscrew_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008A7EA8 */
 static void corkscrew_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -3416,12 +3416,12 @@ static void corkscrew_rc_track_right_half_banked_helix_down_small(paint_session
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     corkscrew_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008A7EB8 */
 static void corkscrew_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3732,7 +3732,7 @@ static void corkscrew_rc_track_left_half_banked_helix_up_large(paint_session * s
 
 /** rct2: 0x008A7EC8 */
 static void corkscrew_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4043,7 +4043,7 @@ static void corkscrew_rc_track_right_half_banked_helix_up_large(paint_session *
 
 /** rct2: 0x008A7ED8 */
 static void corkscrew_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -4052,12 +4052,12 @@ static void corkscrew_rc_track_left_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     corkscrew_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008A7EE8 */
 static void corkscrew_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -4066,12 +4066,12 @@ static void corkscrew_rc_track_right_half_banked_helix_down_large(paint_session
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     corkscrew_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008A7F18 */
 static void corkscrew_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4107,7 +4107,7 @@ static void corkscrew_rc_track_left_quarter_turn_1_60_deg_up(paint_session * ses
 
 /** rct2: 0x008A7EF8 */
 static void corkscrew_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4143,23 +4143,23 @@ static void corkscrew_rc_track_right_quarter_turn_1_60_deg_up(paint_session * se
 
 /** rct2: 0x008A7F08 */
 static void corkscrew_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     corkscrew_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A7F28 */
 static void corkscrew_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     corkscrew_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A7F38 */
 static void corkscrew_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4186,7 +4186,7 @@ static void corkscrew_rc_track_brakes(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A7F48 */
 static void corkscrew_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4219,7 +4219,7 @@ static void corkscrew_rc_track_on_ride_photo(paint_session * session, uint8 ride
                            height + 3);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_0);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -4227,7 +4227,7 @@ static void corkscrew_rc_track_on_ride_photo(paint_session * session, uint8 ride
 
 /** rct2: 0x008A8198 */
 static void corkscrew_rc_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4361,7 +4361,7 @@ static void corkscrew_rc_track_flat_to_60_deg_up_long_base(paint_session * sessi
 
 /** rct2: 0x008A81A8 */
 static void corkscrew_rc_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4495,23 +4495,23 @@ static void corkscrew_rc_track_60_deg_up_to_flat_long_base(paint_session * sessi
 
 /** rct2: 0x008A81B8 */
 static void corkscrew_rc_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     corkscrew_rc_track_flat_to_60_deg_up_long_base(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height,
-                                                   mapElement);
+                                                   tileElement);
 }
 
 /** rct2: 0x008A81C8 */
 static void corkscrew_rc_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     corkscrew_rc_track_60_deg_up_to_flat_long_base(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height,
-                                                   mapElement);
+                                                   tileElement);
 }
 
 /** rct2: 0x008A7F68 */
 static void corkscrew_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4635,7 +4635,7 @@ static void corkscrew_rc_track_left_eighth_to_diag(paint_session * session, uint
 
 /** rct2: 0x008A7F78 */
 static void corkscrew_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4759,23 +4759,23 @@ static void corkscrew_rc_track_right_eighth_to_diag(paint_session * session, uin
 
 /** rct2: 0x008A7F88 */
 static void corkscrew_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    corkscrew_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7F98 */
 static void corkscrew_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    corkscrew_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    corkscrew_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7FA8 */
 static void corkscrew_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4899,7 +4899,7 @@ static void corkscrew_rc_track_left_eighth_bank_to_diag(paint_session * session,
 
 /** rct2: 0x008A7FB8 */
 static void corkscrew_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5023,28 +5023,28 @@ static void corkscrew_rc_track_right_eighth_bank_to_diag(paint_session * session
 
 /** rct2: 0x008A7FC8 */
 static void corkscrew_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    corkscrew_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    corkscrew_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7FD8 */
 static void corkscrew_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    corkscrew_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    corkscrew_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7F58 */
 static void corkscrew_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5069,7 +5069,7 @@ static void corkscrew_rc_track_diag_flat(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5094,7 +5094,7 @@ static void corkscrew_rc_track_diag_flat(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5119,7 +5119,7 @@ static void corkscrew_rc_track_diag_flat(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5176,12 +5176,12 @@ static void corkscrew_rc_track_diag_flat(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A8008 */
 static void corkscrew_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5206,7 +5206,7 @@ static void corkscrew_rc_track_diag_25_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5231,7 +5231,7 @@ static void corkscrew_rc_track_diag_25_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5256,7 +5256,7 @@ static void corkscrew_rc_track_diag_25_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5313,12 +5313,12 @@ static void corkscrew_rc_track_diag_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x008A8068 */
 static void corkscrew_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5343,7 +5343,7 @@ static void corkscrew_rc_track_diag_60_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5368,7 +5368,7 @@ static void corkscrew_rc_track_diag_60_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5393,7 +5393,7 @@ static void corkscrew_rc_track_diag_60_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5450,12 +5450,12 @@ static void corkscrew_rc_track_diag_60_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x008A7FE8 */
 static void corkscrew_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5480,7 +5480,7 @@ static void corkscrew_rc_track_diag_flat_to_25_deg_up(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5505,7 +5505,7 @@ static void corkscrew_rc_track_diag_flat_to_25_deg_up(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5530,7 +5530,7 @@ static void corkscrew_rc_track_diag_flat_to_25_deg_up(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5587,12 +5587,12 @@ static void corkscrew_rc_track_diag_flat_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A8048 */
 static void corkscrew_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5617,7 +5617,7 @@ static void corkscrew_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5642,7 +5642,7 @@ static void corkscrew_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5667,7 +5667,7 @@ static void corkscrew_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5724,12 +5724,12 @@ static void corkscrew_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessi
 
 /** rct2: 0x008A8058 */
 static void corkscrew_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5754,7 +5754,7 @@ static void corkscrew_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5779,7 +5779,7 @@ static void corkscrew_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5804,7 +5804,7 @@ static void corkscrew_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5861,12 +5861,12 @@ static void corkscrew_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008A7FF8 */
 static void corkscrew_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5891,7 +5891,7 @@ static void corkscrew_rc_track_diag_25_deg_up_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5916,7 +5916,7 @@ static void corkscrew_rc_track_diag_25_deg_up_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5941,7 +5941,7 @@ static void corkscrew_rc_track_diag_25_deg_up_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5998,12 +5998,12 @@ static void corkscrew_rc_track_diag_25_deg_up_to_flat(paint_session * session, u
 
 /** rct2: 0x008A8038 */
 static void corkscrew_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6028,7 +6028,7 @@ static void corkscrew_rc_track_diag_25_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6053,7 +6053,7 @@ static void corkscrew_rc_track_diag_25_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6078,7 +6078,7 @@ static void corkscrew_rc_track_diag_25_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6135,12 +6135,12 @@ static void corkscrew_rc_track_diag_25_deg_down(paint_session * session, uint8 r
 
 /** rct2: 0x008A8098 */
 static void corkscrew_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6165,7 +6165,7 @@ static void corkscrew_rc_track_diag_60_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6190,7 +6190,7 @@ static void corkscrew_rc_track_diag_60_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6215,7 +6215,7 @@ static void corkscrew_rc_track_diag_60_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6272,12 +6272,12 @@ static void corkscrew_rc_track_diag_60_deg_down(paint_session * session, uint8 r
 
 /** rct2: 0x008A8018 */
 static void corkscrew_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6301,7 +6301,7 @@ static void corkscrew_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6325,7 +6325,7 @@ static void corkscrew_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6349,7 +6349,7 @@ static void corkscrew_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6407,12 +6407,12 @@ static void corkscrew_rc_track_diag_flat_to_25_deg_down(paint_session * session,
 
 /** rct2: 0x008A8078 */
 static void corkscrew_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6437,7 +6437,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6462,7 +6462,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6487,7 +6487,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6544,12 +6544,12 @@ static void corkscrew_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * s
 
 /** rct2: 0x008A8088 */
 static void corkscrew_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6574,7 +6574,7 @@ static void corkscrew_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6599,7 +6599,7 @@ static void corkscrew_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6624,7 +6624,7 @@ static void corkscrew_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6681,12 +6681,12 @@ static void corkscrew_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * s
 
 /** rct2: 0x008A8028 */
 static void corkscrew_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6711,7 +6711,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6736,7 +6736,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6761,7 +6761,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6818,7 +6818,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_flat(paint_session * session,
 
 /** rct2: 0x008A80C8 */
 static void corkscrew_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6887,7 +6887,7 @@ static void corkscrew_rc_track_diag_flat_to_left_bank(paint_session * session, u
 
 /** rct2: 0x008A80D8 */
 static void corkscrew_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6956,7 +6956,7 @@ static void corkscrew_rc_track_diag_flat_to_right_bank(paint_session * session,
 
 /** rct2: 0x008A80E8 */
 static void corkscrew_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7025,7 +7025,7 @@ static void corkscrew_rc_track_diag_left_bank_to_flat(paint_session * session, u
 
 /** rct2: 0x008A80F8 */
 static void corkscrew_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7094,7 +7094,7 @@ static void corkscrew_rc_track_diag_right_bank_to_flat(paint_session * session,
 
 /** rct2: 0x008A8128 */
 static void corkscrew_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7163,7 +7163,7 @@ static void corkscrew_rc_track_diag_left_bank_to_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008A8138 */
 static void corkscrew_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7232,7 +7232,7 @@ static void corkscrew_rc_track_diag_right_bank_to_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A8108 */
 static void corkscrew_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7301,7 +7301,7 @@ static void corkscrew_rc_track_diag_25_deg_up_to_left_bank(paint_session * sessi
 
 /** rct2: 0x008A8118 */
 static void corkscrew_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7370,7 +7370,7 @@ static void corkscrew_rc_track_diag_25_deg_up_to_right_bank(paint_session * sess
 
 /** rct2: 0x008A8148 */
 static void corkscrew_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7437,7 +7437,7 @@ static void corkscrew_rc_track_diag_left_bank_to_25_deg_down(paint_session * ses
 
 /** rct2: 0x008A8158 */
 static void corkscrew_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7504,7 +7504,7 @@ static void corkscrew_rc_track_diag_right_bank_to_25_deg_down(paint_session * se
 
 /** rct2: 0x008A8168 */
 static void corkscrew_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7573,7 +7573,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_left_bank(paint_session * ses
 
 /** rct2: 0x008A8178 */
 static void corkscrew_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7642,7 +7642,7 @@ static void corkscrew_rc_track_diag_25_deg_down_to_right_bank(paint_session * se
 
 /** rct2: 0x008A80A8 */
 static void corkscrew_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7709,7 +7709,7 @@ static void corkscrew_rc_track_diag_left_bank(paint_session * session, uint8 rid
 
 /** rct2: 0x008A80B8 */
 static void corkscrew_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7776,7 +7776,7 @@ static void corkscrew_rc_track_diag_right_bank(paint_session * session, uint8 ri
 
 /** rct2: 0x008A8188 */
 static void corkscrew_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7799,11 +7799,11 @@ static void corkscrew_rc_track_block_brakes(paint_session * session, uint8 rideI
 }
 
 static void corkscrew_rc_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     if (!is_csg_loaded())
     {
-        corkscrew_rc_track_brakes(session, rideIndex, trackSequence, direction, height, mapElement);
+        corkscrew_rc_track_brakes(session, rideIndex, trackSequence, direction, height, tileElement);
         return;
     }
 
diff --git a/src/openrct2/ride/coaster/FlyingRollerCoaster.cpp b/src/openrct2/ride/coaster/FlyingRollerCoaster.cpp
index 3a8fae461f..e3fa677add 100644
--- a/src/openrct2/ride/coaster/FlyingRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/FlyingRollerCoaster.cpp
@@ -28,11 +28,11 @@
 
 /** rct2: 0x007C6FF4 */
 static void flying_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -87,7 +87,7 @@ static void flying_rc_track_flat(paint_session * session, uint8 rideIndex, uint8
     }
     else
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -135,9 +135,9 @@ static void flying_rc_track_flat(paint_session * session, uint8 rideIndex, uint8
 
 /** rct2: 0x007C7244, 0x007C7254, 0x007C7264 */
 static void flying_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_inverted(mapElement))
+    if (track_element_is_inverted(tileElement))
     {
         static const uint32 imageIds[4][3] = {
             { SPR_STATION_BASE_C_SW_NE, 27131, SPR_STATION_INVERTED_BAR_C_SW_NE },
@@ -152,7 +152,7 @@ static void flying_rc_track_station(paint_session * session, uint8 rideIndex, ui
         sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 1,
                            height + 24, 0, 6, height + 24);
         track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
-        track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
+        track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
                                                STATION_VARIANT_1);
     }
     else
@@ -164,7 +164,7 @@ static void flying_rc_track_station(paint_session * session, uint8 rideIndex, ui
             { 17155, 17151, SPR_STATION_BASE_A_NW_SE },
         };
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
         {
             sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20,
                                1, height, 0, 6, height + 3);
@@ -177,7 +177,7 @@ static void flying_rc_track_station(paint_session * session, uint8 rideIndex, ui
         sub_98196C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                            height);
         track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
-        track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+        track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     }
 
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
@@ -187,9 +187,9 @@ static void flying_rc_track_station(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x007C7004 */
 static void flying_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -229,7 +229,7 @@ static void flying_rc_track_25_deg_up(paint_session * session, uint8 rideIndex,
     }
     else
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -313,9 +313,9 @@ static void flying_rc_track_25_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x007C7014 */
 static void flying_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -390,9 +390,9 @@ static void flying_rc_track_60_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x007C7024 */
 static void flying_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -432,7 +432,7 @@ static void flying_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rid
     }
     else
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -516,9 +516,9 @@ static void flying_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x007C7034 */
 static void flying_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -601,9 +601,9 @@ static void flying_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint
 
 /** rct2: 0x007C7044 */
 static void flying_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -710,9 +710,9 @@ static void flying_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x007C7054 */
 static void flying_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -752,7 +752,7 @@ static void flying_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rid
     }
     else
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -836,51 +836,51 @@ static void flying_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rid
 
 /** rct2: 0x007C7064 */
 static void flying_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7074 */
 static void flying_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7084 */
 static void flying_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7094 */
 static void flying_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C70A4 */
 static void flying_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C70B4 */
 static void flying_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C70C4 */
 static void flying_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -1200,17 +1200,17 @@ static void flying_rc_track_left_quarter_turn_5(paint_session * session, uint8 r
 
 /** rct2: 0x007C70D4 */
 static void flying_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    flying_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C70E4 */
 static void flying_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1284,9 +1284,9 @@ static void flying_rc_track_flat_to_left_bank(paint_session * session, uint8 rid
 
 /** rct2: 0x007C70F4 */
 static void flying_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1360,9 +1360,9 @@ static void flying_rc_track_flat_to_right_bank(paint_session * session, uint8 ri
 
 /** rct2: 0x007C7104 */
 static void flying_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1436,9 +1436,9 @@ static void flying_rc_track_left_bank_to_flat(paint_session * session, uint8 rid
 
 /** rct2: 0x007C7114 */
 static void flying_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1512,9 +1512,9 @@ static void flying_rc_track_right_bank_to_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x007C7124 */
 static void flying_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -1838,17 +1838,17 @@ static void flying_rc_track_banked_left_quarter_turn_5(paint_session * session,
 
 /** rct2: 0x007C7134 */
 static void flying_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    flying_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7144 */
 static void flying_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1953,9 +1953,9 @@ static void flying_rc_track_left_bank_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x007C7154 */
 static void flying_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2060,9 +2060,9 @@ static void flying_rc_track_right_bank_to_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x007C7164 */
 static void flying_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2167,9 +2167,9 @@ static void flying_rc_track_25_deg_up_to_left_bank(paint_session * session, uint
 
 /** rct2: 0x007C7174 */
 static void flying_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2274,37 +2274,37 @@ static void flying_rc_track_25_deg_up_to_right_bank(paint_session * session, uin
 
 /** rct2: 0x007C7184 */
 static void flying_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7194 */
 static void flying_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C71A4 */
 static void flying_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C71B4 */
 static void flying_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C71C4 */
 static void flying_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2374,16 +2374,16 @@ static void flying_rc_track_left_bank(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x007C71D4 */
 static void flying_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C71E4 */
 static void flying_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -2698,9 +2698,9 @@ static void flying_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sessio
 
 /** rct2: 0x007C71F4 */
 static void flying_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3015,25 +3015,25 @@ static void flying_rc_track_right_quarter_turn_5_25_deg_up(paint_session * sessi
 
 /** rct2: 0x007C7204 */
 static void flying_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    flying_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    flying_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7214 */
 static void flying_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    flying_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7224 */
 static void flying_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3321,9 +3321,9 @@ static void flying_rc_track_s_bend_left(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x007C7234 */
 static void flying_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3611,9 +3611,9 @@ static void flying_rc_track_s_bend_right(paint_session * session, uint8 rideInde
 
 /** rct2: 0x007C7274 */
 static void flying_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3819,17 +3819,17 @@ static void flying_rc_track_left_quarter_turn_3(paint_session * session, uint8 r
 
 /** rct2: 0x007C7284 */
 static void flying_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    flying_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7294 */
 static void flying_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4039,17 +4039,17 @@ static void flying_rc_track_left_quarter_turn_3_bank(paint_session * session, ui
 
 /** rct2: 0x007C72A4 */
 static void flying_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    flying_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C72B4 */
 static void flying_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4205,9 +4205,9 @@ static void flying_rc_track_left_quarter_turn_3_25_deg_up(paint_session * sessio
 
 /** rct2: 0x007C72C4 */
 static void flying_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4369,25 +4369,25 @@ static void flying_rc_track_right_quarter_turn_3_25_deg_up(paint_session * sessi
 
 /** rct2: 0x007C72D4 */
 static void flying_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    flying_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    flying_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C72E4 */
 static void flying_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    flying_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7314 */
 static void flying_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4795,9 +4795,9 @@ static void flying_rc_track_left_half_banked_helix_up_small(paint_session * sess
 
 /** rct2: 0x007C7324 */
 static void flying_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5205,7 +5205,7 @@ static void flying_rc_track_right_half_banked_helix_up_small(paint_session * ses
 
 /** rct2: 0x007C7334 */
 static void flying_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -5214,12 +5214,12 @@ static void flying_rc_track_left_half_banked_helix_down_small(paint_session * se
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     flying_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x007C7344 */
 static void flying_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -5227,14 +5227,14 @@ static void flying_rc_track_right_half_banked_helix_down_small(paint_session * s
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    flying_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7354 */
 static void flying_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5870,9 +5870,9 @@ static void flying_rc_track_left_half_banked_helix_up_large(paint_session * sess
 
 /** rct2: 0x007C7364 */
 static void flying_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -6508,7 +6508,7 @@ static void flying_rc_track_right_half_banked_helix_up_large(paint_session * ses
 
 /** rct2: 0x007C7374 */
 static void flying_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -6517,12 +6517,12 @@ static void flying_rc_track_left_half_banked_helix_down_large(paint_session * se
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     flying_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x007C7384 */
 static void flying_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -6530,14 +6530,14 @@ static void flying_rc_track_right_half_banked_helix_down_large(paint_session * s
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    flying_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C73B4 */
 static void flying_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -6605,9 +6605,9 @@ static void flying_rc_track_left_quarter_turn_1_60_deg_up(paint_session * sessio
 
 /** rct2: 0x007C7394 */
 static void flying_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -6674,23 +6674,23 @@ static void flying_rc_track_right_quarter_turn_1_60_deg_up(paint_session * sessi
 
 /** rct2: 0x007C73A4 */
 static void flying_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    flying_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C73C4 */
 static void flying_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    flying_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C73D4 */
 static void flying_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -6746,9 +6746,9 @@ static void flying_rc_track_brakes(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x007C7674 */
 static void flying_rc_track_left_quarter_banked_helix_large_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -7074,9 +7074,9 @@ static void flying_rc_track_left_quarter_banked_helix_large_up(paint_session * s
 
 /** rct2: 0x007C7684 */
 static void flying_rc_track_right_quarter_banked_helix_large_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -7402,9 +7402,9 @@ static void flying_rc_track_right_quarter_banked_helix_large_up(paint_session *
 
 /** rct2: 0x007C7694 */
 static void flying_rc_track_left_quarter_banked_helix_large_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -7730,9 +7730,9 @@ static void flying_rc_track_left_quarter_banked_helix_large_down(paint_session *
 
 /** rct2: 0x007C76A4 */
 static void flying_rc_track_right_quarter_banked_helix_large_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8058,9 +8058,9 @@ static void flying_rc_track_right_quarter_banked_helix_large_down(paint_session
 
 /** rct2: 0x007C78B4 */
 static void flying_rc_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -8159,9 +8159,9 @@ static void flying_rc_track_25_deg_up_left_banked(paint_session * session, uint8
 
 /** rct2: 0x007C78C4 */
 static void flying_rc_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -8260,9 +8260,9 @@ static void flying_rc_track_25_deg_up_right_banked(paint_session * session, uint
 
 /** rct2: 0x007C73E4 */
 static void flying_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -8303,7 +8303,7 @@ static void flying_rc_track_on_ride_photo(paint_session * session, uint8 rideInd
                                height + 3);
             break;
         }
-        track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+        track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
         paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -8349,7 +8349,7 @@ static void flying_rc_track_on_ride_photo(paint_session * session, uint8 rideInd
                                6, height + 24);
             break;
         }
-        track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+        track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
         paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         paint_util_set_general_support_height(session, height + 64, 0x20);
@@ -8358,23 +8358,23 @@ static void flying_rc_track_on_ride_photo(paint_session * session, uint8 rideInd
 
 /** rct2: 0x007C78D4 */
 static void flying_rc_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C78E4 */
 static void flying_rc_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7404 */
 static void flying_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8649,9 +8649,9 @@ static void flying_rc_track_left_eighth_to_diag(paint_session * session, uint8 r
 
 /** rct2: 0x007C7414 */
 static void flying_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8926,25 +8926,25 @@ static void flying_rc_track_right_eighth_to_diag(paint_session * session, uint8
 
 /** rct2: 0x007C7424 */
 static void flying_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    flying_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7434 */
 static void flying_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    flying_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    flying_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7444 */
 static void flying_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -9219,9 +9219,9 @@ static void flying_rc_track_left_eighth_bank_to_diag(paint_session * session, ui
 
 /** rct2: 0x007C7454 */
 static void flying_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -9496,30 +9496,30 @@ static void flying_rc_track_right_eighth_bank_to_diag(paint_session * session, u
 
 /** rct2: 0x007C7464 */
 static void flying_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    flying_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7474 */
 static void flying_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    flying_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    flying_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C73F4 */
 static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9544,7 +9544,7 @@ static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9569,7 +9569,7 @@ static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9594,7 +9594,7 @@ static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9653,7 +9653,7 @@ static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9678,7 +9678,7 @@ static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9703,7 +9703,7 @@ static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9728,7 +9728,7 @@ static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9779,14 +9779,14 @@ static void flying_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x007C74A4 */
 static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9811,7 +9811,7 @@ static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9836,7 +9836,7 @@ static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9861,7 +9861,7 @@ static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9920,7 +9920,7 @@ static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9945,7 +9945,7 @@ static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9970,7 +9970,7 @@ static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9995,7 +9995,7 @@ static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10046,14 +10046,14 @@ static void flying_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x007C7504 */
 static void flying_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10078,7 +10078,7 @@ static void flying_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10103,7 +10103,7 @@ static void flying_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10128,7 +10128,7 @@ static void flying_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIn
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10261,14 +10261,14 @@ static void flying_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x007C7484 */
 static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10293,7 +10293,7 @@ static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10318,7 +10318,7 @@ static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10343,7 +10343,7 @@ static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10402,7 +10402,7 @@ static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10427,7 +10427,7 @@ static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10452,7 +10452,7 @@ static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10477,7 +10477,7 @@ static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10528,14 +10528,14 @@ static void flying_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x007C74E4 */
 static void flying_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10560,7 +10560,7 @@ static void flying_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session,
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10585,7 +10585,7 @@ static void flying_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session,
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10610,7 +10610,7 @@ static void flying_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session,
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10743,14 +10743,14 @@ static void flying_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session,
 
 /** rct2: 0x007C74F4 */
 static void flying_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10775,7 +10775,7 @@ static void flying_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session,
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10800,7 +10800,7 @@ static void flying_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session,
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10825,7 +10825,7 @@ static void flying_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session,
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10958,14 +10958,14 @@ static void flying_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x007C7494 */
 static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10990,7 +10990,7 @@ static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11015,7 +11015,7 @@ static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11040,7 +11040,7 @@ static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11099,7 +11099,7 @@ static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11124,7 +11124,7 @@ static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11149,7 +11149,7 @@ static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11174,7 +11174,7 @@ static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11225,14 +11225,14 @@ static void flying_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
 
 /** rct2: 0x007C74D4 */
 static void flying_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11257,7 +11257,7 @@ static void flying_rc_track_diag_25_deg_down(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11282,7 +11282,7 @@ static void flying_rc_track_diag_25_deg_down(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11307,7 +11307,7 @@ static void flying_rc_track_diag_25_deg_down(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11440,14 +11440,14 @@ static void flying_rc_track_diag_25_deg_down(paint_session * session, uint8 ride
 
 /** rct2: 0x007C7534 */
 static void flying_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11472,7 +11472,7 @@ static void flying_rc_track_diag_60_deg_down(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11497,7 +11497,7 @@ static void flying_rc_track_diag_60_deg_down(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11522,7 +11522,7 @@ static void flying_rc_track_diag_60_deg_down(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11655,14 +11655,14 @@ static void flying_rc_track_diag_60_deg_down(paint_session * session, uint8 ride
 
 /** rct2: 0x007C74B4 */
 static void flying_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11686,7 +11686,7 @@ static void flying_rc_track_diag_flat_to_25_deg_down(paint_session * session, ui
                 session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11710,7 +11710,7 @@ static void flying_rc_track_diag_flat_to_25_deg_down(paint_session * session, ui
                 session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11734,7 +11734,7 @@ static void flying_rc_track_diag_flat_to_25_deg_down(paint_session * session, ui
                 session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11863,14 +11863,14 @@ static void flying_rc_track_diag_flat_to_25_deg_down(paint_session * session, ui
 
 /** rct2: 0x007C7514 */
 static void flying_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11895,7 +11895,7 @@ static void flying_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * sess
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11920,7 +11920,7 @@ static void flying_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * sess
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11945,7 +11945,7 @@ static void flying_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * sess
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12078,14 +12078,14 @@ static void flying_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * sess
 
 /** rct2: 0x007C7524 */
 static void flying_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12110,7 +12110,7 @@ static void flying_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * sess
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12135,7 +12135,7 @@ static void flying_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * sess
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12160,7 +12160,7 @@ static void flying_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * sess
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12293,14 +12293,14 @@ static void flying_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * sess
 
 /** rct2: 0x007C74C4 */
 static void flying_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12325,7 +12325,7 @@ static void flying_rc_track_diag_25_deg_down_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12350,7 +12350,7 @@ static void flying_rc_track_diag_25_deg_down_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12375,7 +12375,7 @@ static void flying_rc_track_diag_25_deg_down_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12508,9 +12508,9 @@ static void flying_rc_track_diag_25_deg_down_to_flat(paint_session * session, ui
 
 /** rct2: 0x007C7564 */
 static void flying_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12660,9 +12660,9 @@ static void flying_rc_track_diag_flat_to_left_bank(paint_session * session, uint
 
 /** rct2: 0x007C7574 */
 static void flying_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12812,9 +12812,9 @@ static void flying_rc_track_diag_flat_to_right_bank(paint_session * session, uin
 
 /** rct2: 0x007C7584 */
 static void flying_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12964,9 +12964,9 @@ static void flying_rc_track_diag_left_bank_to_flat(paint_session * session, uint
 
 /** rct2: 0x007C7594 */
 static void flying_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13116,9 +13116,9 @@ static void flying_rc_track_diag_right_bank_to_flat(paint_session * session, uin
 
 /** rct2: 0x007C75C4 */
 static void flying_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13267,9 +13267,9 @@ static void flying_rc_track_diag_left_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x007C75D4 */
 static void flying_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13418,9 +13418,9 @@ static void flying_rc_track_diag_right_bank_to_25_deg_up(paint_session * session
 
 /** rct2: 0x007C75A4 */
 static void flying_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13569,9 +13569,9 @@ static void flying_rc_track_diag_25_deg_up_to_left_bank(paint_session * session,
 
 /** rct2: 0x007C75B4 */
 static void flying_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13720,9 +13720,9 @@ static void flying_rc_track_diag_25_deg_up_to_right_bank(paint_session * session
 
 /** rct2: 0x007C75E4 */
 static void flying_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13864,9 +13864,9 @@ static void flying_rc_track_diag_left_bank_to_25_deg_down(paint_session * sessio
 
 /** rct2: 0x007C75F4 */
 static void flying_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14008,9 +14008,9 @@ static void flying_rc_track_diag_right_bank_to_25_deg_down(paint_session * sessi
 
 /** rct2: 0x007C7604 */
 static void flying_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14159,9 +14159,9 @@ static void flying_rc_track_diag_25_deg_down_to_left_bank(paint_session * sessio
 
 /** rct2: 0x007C7614 */
 static void flying_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14310,9 +14310,9 @@ static void flying_rc_track_diag_25_deg_down_to_right_bank(paint_session * sessi
 
 /** rct2: 0x007C7544 */
 static void flying_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14460,9 +14460,9 @@ static void flying_rc_track_diag_left_bank(paint_session * session, uint8 rideIn
 
 /** rct2: 0x007C7554 */
 static void flying_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14610,9 +14610,9 @@ static void flying_rc_track_diag_right_bank(paint_session * session, uint8 rideI
 
 /** rct2: 0x007C7624 */
 static void flying_rc_track_left_flyer_twist_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14828,9 +14828,9 @@ static void flying_rc_track_left_flyer_twist_up(paint_session * session, uint8 r
 
 /** rct2: 0x007C7634 */
 static void flying_rc_track_right_flyer_twist_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15046,9 +15046,9 @@ static void flying_rc_track_right_flyer_twist_up(paint_session * session, uint8
 
 /** rct2: 0x007C7644 */
 static void flying_rc_track_left_flyer_twist_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15264,9 +15264,9 @@ static void flying_rc_track_left_flyer_twist_down(paint_session * session, uint8
 
 /** rct2: 0x007C7654 */
 static void flying_rc_track_right_flyer_twist_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15482,9 +15482,9 @@ static void flying_rc_track_right_flyer_twist_down(paint_session * session, uint
 
 /** rct2: 0x007C72F4 */
 static void flying_rc_track_flyer_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15718,9 +15718,9 @@ static void flying_rc_track_flyer_half_loop_up(paint_session * session, uint8 ri
 
 /** rct2: 0x007C7304 */
 static void flying_rc_track_flyer_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15954,9 +15954,9 @@ static void flying_rc_track_flyer_half_loop_down(paint_session * session, uint8
 
 /** rct2: 0x007C7664 */
 static void flying_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -16009,9 +16009,9 @@ static void flying_rc_track_block_brakes(paint_session * session, uint8 rideInde
 
 /** rct2: 0x007C76B4 */
 static void flying_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -16170,9 +16170,9 @@ static void flying_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session *
 
 /** rct2: 0x007C76C4 */
 static void flying_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -16338,28 +16338,28 @@ static void flying_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session
 /** rct2: 0x007C76D4 */
 static void flying_rc_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     flying_rc_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x007C76E4 */
 static void flying_rc_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     flying_rc_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x007C76F4 */
 static void flying_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -16677,9 +16677,9 @@ static void flying_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session *
 
 /** rct2: 0x007C7704 */
 static void flying_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -16998,28 +16998,28 @@ static void flying_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session
 /** rct2: 0x007C7714 */
 static void flying_rc_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     flying_rc_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x007C7724 */
 static void flying_rc_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     flying_rc_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x007C7734 */
 static void flying_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -17120,9 +17120,9 @@ static void flying_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * s
 
 /** rct2: 0x007C7744 */
 static void flying_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -17223,9 +17223,9 @@ static void flying_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session *
 
 /** rct2: 0x007C7754 */
 static void flying_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -17326,9 +17326,9 @@ static void flying_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * s
 
 /** rct2: 0x007C7764 */
 static void flying_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -17430,45 +17430,45 @@ static void flying_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session *
 /** rct2: 0x007C7774 */
 static void flying_rc_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     flying_rc_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x007C7784 */
 static void flying_rc_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     flying_rc_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x007C7794 */
 static void flying_rc_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     flying_rc_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x007C77A4 */
 static void flying_rc_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     flying_rc_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x007C77B4 */
 static void flying_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -17568,9 +17568,9 @@ static void flying_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_sess
 /** rct2: 0x007C77C4 */
 static void flying_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -17670,9 +17670,9 @@ static void flying_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_se
 /** rct2: 0x007C77F4 */
 static void flying_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -17772,9 +17772,9 @@ static void flying_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_sess
 /** rct2: 0x007C7804 */
 static void flying_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -17874,44 +17874,44 @@ static void flying_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_se
 /** rct2: 0x007C7814 */
 static void flying_rc_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     flying_rc_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                mapElement);
+                                                                tileElement);
 }
 
 /** rct2: 0x007C7824 */
 static void flying_rc_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     flying_rc_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x007C77D4 */
 static void flying_rc_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     flying_rc_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                mapElement);
+                                                                tileElement);
 }
 
 /** rct2: 0x007C77E4 */
 static void flying_rc_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     flying_rc_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x007C7834 */
 static void flying_rc_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -18012,9 +18012,9 @@ static void flying_rc_track_flat_to_left_banked_25_deg_up(paint_session * sessio
 
 /** rct2: 0x007C7844 */
 static void flying_rc_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -18115,9 +18115,9 @@ static void flying_rc_track_flat_to_right_banked_25_deg_up(paint_session * sessi
 
 /** rct2: 0x007C7854 */
 static void flying_rc_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -18218,9 +18218,9 @@ static void flying_rc_track_left_banked_25_deg_up_to_flat(paint_session * sessio
 
 /** rct2: 0x007C7864 */
 static void flying_rc_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -18321,30 +18321,30 @@ static void flying_rc_track_right_banked_25_deg_up_to_flat(paint_session * sessi
 
 /** rct2: 0x007C7874 */
 static void flying_rc_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7884 */
 static void flying_rc_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C7894 */
 static void flying_rc_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007C78A4 */
 static void flying_rc_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    flying_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    flying_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_flying_rc(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/coaster/GigaCoaster.cpp b/src/openrct2/ride/coaster/GigaCoaster.cpp
index 82c873b7e8..f0ffdf4646 100644
--- a/src/openrct2/ride/coaster/GigaCoaster.cpp
+++ b/src/openrct2/ride/coaster/GigaCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008AD674 */
 static void giga_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                               rct_tile_element * mapElement)
+                               rct_tile_element * tileElement)
 {
-    if (track_element_is_cable_lift(mapElement))
+    if (track_element_is_cable_lift(tileElement))
     {
         switch (direction)
         {
@@ -50,7 +50,7 @@ static void giga_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 t
             metal_a_supports_paint_setup(session, METAL_SUPPORTS_TUBES, 4, 0, height, session->TrackColours[SCHEME_SUPPORTS]);
         }
     }
-    else if (track_element_is_lift_hill(mapElement))
+    else if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -103,7 +103,7 @@ static void giga_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 t
 }
 
 static void giga_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                  rct_tile_element * mapElement)
+                                  rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 18084, 18076, SPR_STATION_BASE_A_SW_NE },
@@ -112,7 +112,7 @@ static void giga_rc_track_station(paint_session * session, uint8 rideIndex, uint
         { 18085, 18077, SPR_STATION_BASE_A_NW_SE },
     };
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20, 1,
                            height, 0, 6, height + 3);
@@ -125,7 +125,7 @@ static void giga_rc_track_station(paint_session * session, uint8 rideIndex, uint
     sub_98196C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -133,9 +133,9 @@ static void giga_rc_track_station(paint_session * session, uint8 rideIndex, uint
 
 /** rct2: 0x008AD684 */
 static void giga_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_cable_lift(mapElement))
+    if (track_element_is_cable_lift(tileElement))
     {
         switch (direction)
         {
@@ -161,7 +161,7 @@ static void giga_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, ui
             metal_a_supports_paint_setup(session, METAL_SUPPORTS_TUBES, 4, 8, height, session->TrackColours[SCHEME_SUPPORTS]);
         }
     }
-    else if (track_element_is_lift_hill(mapElement))
+    else if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -228,9 +228,9 @@ static void giga_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008AD694 */
 static void giga_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_cable_lift(mapElement))
+    if (track_element_is_cable_lift(tileElement))
     {
         switch (direction)
         {
@@ -297,9 +297,9 @@ static void giga_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008AD6A4 */
 static void giga_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_cable_lift(mapElement))
+    if (track_element_is_cable_lift(tileElement))
     {
         switch (direction)
         {
@@ -325,7 +325,7 @@ static void giga_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideI
             metal_a_supports_paint_setup(session, METAL_SUPPORTS_TUBES, 4, 3, height, session->TrackColours[SCHEME_SUPPORTS]);
         }
     }
-    else if (track_element_is_lift_hill(mapElement))
+    else if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -392,9 +392,9 @@ static void giga_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideI
 
 /** rct2: 0x008AD6B4 */
 static void giga_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_cable_lift(mapElement))
+    if (track_element_is_cable_lift(tileElement))
     {
         switch (direction)
         {
@@ -469,9 +469,9 @@ static void giga_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008AD6C4 */
 static void giga_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_cable_lift(mapElement))
+    if (track_element_is_cable_lift(tileElement))
     {
         switch (direction)
         {
@@ -546,9 +546,9 @@ static void giga_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008AD6D4 */
 static void giga_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_cable_lift(mapElement))
+    if (track_element_is_cable_lift(tileElement))
     {
         switch (direction)
         {
@@ -574,7 +574,7 @@ static void giga_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideI
             metal_a_supports_paint_setup(session, METAL_SUPPORTS_TUBES, 4, 6, height, session->TrackColours[SCHEME_SUPPORTS]);
         }
     }
-    else if (track_element_is_lift_hill(mapElement))
+    else if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -641,49 +641,49 @@ static void giga_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideI
 
 /** rct2: 0x008AD6E4 */
 static void giga_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD6F4 */
 static void giga_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD704 */
 static void giga_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD714 */
 static void giga_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD724 */
 static void giga_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD734 */
 static void giga_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD744 */
 static void giga_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -837,15 +837,15 @@ static void giga_rc_track_left_quarter_turn_5(paint_session * session, uint8 rid
 
 /** rct2: 0x008AD754 */
 static void giga_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    giga_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD764 */
 static void giga_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -882,7 +882,7 @@ static void giga_rc_track_flat_to_left_bank(paint_session * session, uint8 rideI
 
 /** rct2: 0x008AD774 */
 static void giga_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -919,7 +919,7 @@ static void giga_rc_track_flat_to_right_bank(paint_session * session, uint8 ride
 
 /** rct2: 0x008AD784 */
 static void giga_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -956,7 +956,7 @@ static void giga_rc_track_left_bank_to_flat(paint_session * session, uint8 rideI
 
 /** rct2: 0x008AD794 */
 static void giga_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -993,7 +993,7 @@ static void giga_rc_track_right_bank_to_flat(paint_session * session, uint8 ride
 
 /** rct2: 0x008AD7A4 */
 static void giga_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1151,15 +1151,15 @@ static void giga_rc_track_banked_left_quarter_turn_5(paint_session * session, ui
 
 /** rct2: 0x008AD7B4 */
 static void giga_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    giga_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD7C4 */
 static void giga_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1203,7 +1203,7 @@ static void giga_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008AD7D4 */
 static void giga_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1247,7 +1247,7 @@ static void giga_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008AD7E4 */
 static void giga_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1291,7 +1291,7 @@ static void giga_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8
 
 /** rct2: 0x008AD7F4 */
 static void giga_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1335,35 +1335,35 @@ static void giga_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x008AD804 */
 static void giga_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD814 */
 static void giga_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD824 */
 static void giga_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD834 */
 static void giga_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD844 */
 static void giga_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1396,14 +1396,14 @@ static void giga_rc_track_left_bank(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008AD854 */
 static void giga_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD864 */
 static void giga_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1552,7 +1552,7 @@ static void giga_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session,
 
 /** rct2: 0x008AD874 */
 static void giga_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1701,23 +1701,23 @@ static void giga_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session
 
 /** rct2: 0x008AD884 */
 static void giga_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    giga_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    giga_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD894 */
 static void giga_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    giga_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD8A4 */
 static void giga_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1841,7 +1841,7 @@ static void giga_rc_track_s_bend_left(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008AD8B4 */
 static void giga_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1965,7 +1965,7 @@ static void giga_rc_track_s_bend_right(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008AD8F4 */
 static void giga_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2064,15 +2064,15 @@ static void giga_rc_track_left_quarter_turn_3(paint_session * session, uint8 rid
 
 /** rct2: 0x008AD904 */
 static void giga_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    giga_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD914 */
 static void giga_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2175,15 +2175,15 @@ static void giga_rc_track_left_quarter_turn_3_bank(paint_session * session, uint
 
 /** rct2: 0x008AD924 */
 static void giga_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    giga_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD934 */
 static void giga_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2253,7 +2253,7 @@ static void giga_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session,
 
 /** rct2: 0x008AD944 */
 static void giga_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2326,23 +2326,23 @@ static void giga_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session
 
 /** rct2: 0x008AD954 */
 static void giga_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    giga_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    giga_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD964 */
 static void giga_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    giga_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD974 */
 static void giga_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2543,7 +2543,7 @@ static void giga_rc_track_left_half_banked_helix_up_small(paint_session * sessio
 
 /** rct2: 0x008AD984 */
 static void giga_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2744,7 +2744,7 @@ static void giga_rc_track_right_half_banked_helix_up_small(paint_session * sessi
 
 /** rct2: 0x008AD994 */
 static void giga_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2752,12 +2752,12 @@ static void giga_rc_track_left_half_banked_helix_down_small(paint_session * sess
         direction = (direction - 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    giga_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    giga_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD9A4 */
 static void giga_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2765,12 +2765,12 @@ static void giga_rc_track_right_half_banked_helix_down_small(paint_session * ses
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    giga_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD9B4 */
 static void giga_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3081,7 +3081,7 @@ static void giga_rc_track_left_half_banked_helix_up_large(paint_session * sessio
 
 /** rct2: 0x008AD9C4 */
 static void giga_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3398,7 +3398,7 @@ static void giga_rc_track_right_half_banked_helix_up_large(paint_session * sessi
 
 /** rct2: 0x008AD9D4 */
 static void giga_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3406,12 +3406,12 @@ static void giga_rc_track_left_half_banked_helix_down_large(paint_session * sess
         direction = (direction - 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    giga_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    giga_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AD9E4 */
 static void giga_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3419,12 +3419,12 @@ static void giga_rc_track_right_half_banked_helix_down_large(paint_session * ses
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    giga_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADA14 */
 static void giga_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3460,7 +3460,7 @@ static void giga_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session,
 
 /** rct2: 0x008AD9F4 */
 static void giga_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3496,21 +3496,21 @@ static void giga_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session
 
 /** rct2: 0x008ADA04 */
 static void giga_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    giga_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADA24 */
 static void giga_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    giga_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADA34 */
 static void giga_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3541,7 +3541,7 @@ static void giga_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8
 
 /** rct2: 0x008ADC84 */
 static void giga_rc_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3581,7 +3581,7 @@ static void giga_rc_track_25_deg_up_left_banked(paint_session * session, uint8 r
 
 /** rct2: 0x008ADC94 */
 static void giga_rc_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3621,7 +3621,7 @@ static void giga_rc_track_25_deg_up_right_banked(paint_session * session, uint8
 
 /** rct2: 0x008ADA44 */
 static void giga_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3654,7 +3654,7 @@ static void giga_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex
                            height + 3);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -3662,26 +3662,26 @@ static void giga_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008ADCA4 */
 static void giga_rc_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADCB4 */
 static void giga_rc_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADED4 */
 static void giga_rc_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_cable_lift(mapElement))
+        if (track_element_is_cable_lift(tileElement))
         {
             switch (direction)
             {
@@ -3744,7 +3744,7 @@ static void giga_rc_track_flat_to_60_deg_up_long_base(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_cable_lift(mapElement))
+        if (track_element_is_cable_lift(tileElement))
         {
             switch (direction)
             {
@@ -3803,7 +3803,7 @@ static void giga_rc_track_flat_to_60_deg_up_long_base(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_cable_lift(mapElement))
+        if (track_element_is_cable_lift(tileElement))
         {
             switch (direction)
             {
@@ -3862,7 +3862,7 @@ static void giga_rc_track_flat_to_60_deg_up_long_base(paint_session * session, u
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_cable_lift(mapElement))
+        if (track_element_is_cable_lift(tileElement))
         {
             switch (direction)
             {
@@ -3934,7 +3934,7 @@ static void giga_rc_track_flat_to_60_deg_up_long_base(paint_session * session, u
 
 /** rct2: 0x008ADEE4 */
 static void giga_rc_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4068,21 +4068,21 @@ static void giga_rc_track_60_deg_up_to_flat_long_base(paint_session * session, u
 
 /** rct2: 0x008ADEF4 */
 static void giga_rc_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_flat_to_60_deg_up_long_base(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_flat_to_60_deg_up_long_base(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADF04 */
 static void giga_rc_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_60_deg_up_to_flat_long_base(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_60_deg_up_to_flat_long_base(session, rideIndex, 3 - trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADF14 */
 static void giga_rc_track_cable_lift_hill(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4239,7 +4239,7 @@ static void giga_rc_track_cable_lift_hill(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008ADA64 */
 static void giga_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4363,7 +4363,7 @@ static void giga_rc_track_left_eighth_to_diag(paint_session * session, uint8 rid
 
 /** rct2: 0x008ADA74 */
 static void giga_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4487,23 +4487,23 @@ static void giga_rc_track_right_eighth_to_diag(paint_session * session, uint8 ri
 
 /** rct2: 0x008ADA84 */
 static void giga_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    giga_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADA94 */
 static void giga_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    giga_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    giga_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADAA4 */
 static void giga_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4627,7 +4627,7 @@ static void giga_rc_track_left_eighth_bank_to_diag(paint_session * session, uint
 
 /** rct2: 0x008ADAB4 */
 static void giga_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4751,28 +4751,28 @@ static void giga_rc_track_right_eighth_bank_to_diag(paint_session * session, uin
 
 /** rct2: 0x008ADAC4 */
 static void giga_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    giga_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADAD4 */
 static void giga_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    giga_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    giga_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADA54 */
 static void giga_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4797,7 +4797,7 @@ static void giga_rc_track_diag_flat(paint_session * session, uint8 rideIndex, ui
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4822,7 +4822,7 @@ static void giga_rc_track_diag_flat(paint_session * session, uint8 rideIndex, ui
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4847,7 +4847,7 @@ static void giga_rc_track_diag_flat(paint_session * session, uint8 rideIndex, ui
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4904,12 +4904,12 @@ static void giga_rc_track_diag_flat(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008ADB04 */
 static void giga_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4934,7 +4934,7 @@ static void giga_rc_track_diag_25_deg_up(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4959,7 +4959,7 @@ static void giga_rc_track_diag_25_deg_up(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4984,7 +4984,7 @@ static void giga_rc_track_diag_25_deg_up(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5041,7 +5041,7 @@ static void giga_rc_track_diag_25_deg_up(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008ADB64 */
 static void giga_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5108,12 +5108,12 @@ static void giga_rc_track_diag_60_deg_up(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008ADAE4 */
 static void giga_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5138,7 +5138,7 @@ static void giga_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5163,7 +5163,7 @@ static void giga_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5188,7 +5188,7 @@ static void giga_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5245,7 +5245,7 @@ static void giga_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008ADB44 */
 static void giga_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5312,7 +5312,7 @@ static void giga_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, u
 
 /** rct2: 0x008ADB54 */
 static void giga_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5379,12 +5379,12 @@ static void giga_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008ADAF4 */
 static void giga_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5409,7 +5409,7 @@ static void giga_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5434,7 +5434,7 @@ static void giga_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5459,7 +5459,7 @@ static void giga_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5516,12 +5516,12 @@ static void giga_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008ADB34 */
 static void giga_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5546,7 +5546,7 @@ static void giga_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5571,7 +5571,7 @@ static void giga_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5596,7 +5596,7 @@ static void giga_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5653,7 +5653,7 @@ static void giga_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008ADB94 */
 static void giga_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5720,12 +5720,12 @@ static void giga_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008ADB14 */
 static void giga_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5749,7 +5749,7 @@ static void giga_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5773,7 +5773,7 @@ static void giga_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5797,7 +5797,7 @@ static void giga_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5855,7 +5855,7 @@ static void giga_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint
 
 /** rct2: 0x008ADB74 */
 static void giga_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5922,7 +5922,7 @@ static void giga_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * sessio
 
 /** rct2: 0x008ADB84 */
 static void giga_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5989,12 +5989,12 @@ static void giga_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * sessio
 
 /** rct2: 0x008ADB24 */
 static void giga_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6019,7 +6019,7 @@ static void giga_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6044,7 +6044,7 @@ static void giga_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6069,7 +6069,7 @@ static void giga_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6126,7 +6126,7 @@ static void giga_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint
 
 /** rct2: 0x008ADBC4 */
 static void giga_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6195,7 +6195,7 @@ static void giga_rc_track_diag_flat_to_left_bank(paint_session * session, uint8
 
 /** rct2: 0x008ADBD4 */
 static void giga_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6264,7 +6264,7 @@ static void giga_rc_track_diag_flat_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x008ADBE4 */
 static void giga_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6333,7 +6333,7 @@ static void giga_rc_track_diag_left_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008ADBF4 */
 static void giga_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6402,7 +6402,7 @@ static void giga_rc_track_diag_right_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008ADC24 */
 static void giga_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6471,7 +6471,7 @@ static void giga_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008ADC34 */
 static void giga_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6540,7 +6540,7 @@ static void giga_rc_track_diag_right_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008ADC04 */
 static void giga_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6609,7 +6609,7 @@ static void giga_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, u
 
 /** rct2: 0x008ADC14 */
 static void giga_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6678,7 +6678,7 @@ static void giga_rc_track_diag_25_deg_up_to_right_bank(paint_session * session,
 
 /** rct2: 0x008ADC44 */
 static void giga_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6745,7 +6745,7 @@ static void giga_rc_track_diag_left_bank_to_25_deg_down(paint_session * session,
 
 /** rct2: 0x008ADC54 */
 static void giga_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6812,7 +6812,7 @@ static void giga_rc_track_diag_right_bank_to_25_deg_down(paint_session * session
 
 /** rct2: 0x008ADC64 */
 static void giga_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6881,7 +6881,7 @@ static void giga_rc_track_diag_25_deg_down_to_left_bank(paint_session * session,
 
 /** rct2: 0x008ADC74 */
 static void giga_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6950,7 +6950,7 @@ static void giga_rc_track_diag_25_deg_down_to_right_bank(paint_session * session
 
 /** rct2: 0x008ADBA4 */
 static void giga_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7017,7 +7017,7 @@ static void giga_rc_track_diag_left_bank(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008ADBB4 */
 static void giga_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7084,7 +7084,7 @@ static void giga_rc_track_diag_right_bank(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008ADEC4 */
 static void giga_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7115,7 +7115,7 @@ static void giga_rc_track_block_brakes(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008ADCC4 */
 static void giga_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7188,7 +7188,7 @@ static void giga_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * s
 
 /** rct2: 0x008ADCD4 */
 static void giga_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7264,25 +7264,25 @@ static void giga_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session *
 
 /** rct2: 0x008ADCE4 */
 static void giga_rc_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     giga_rc_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008ADCF4 */
 static void giga_rc_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     giga_rc_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008ADD04 */
 static void giga_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7434,7 +7434,7 @@ static void giga_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * s
 
 /** rct2: 0x008ADD14 */
 static void giga_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7586,25 +7586,25 @@ static void giga_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session *
 
 /** rct2: 0x008ADD24 */
 static void giga_rc_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     giga_rc_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008ADD34 */
 static void giga_rc_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     giga_rc_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008ADD44 */
 static void giga_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7646,7 +7646,7 @@ static void giga_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * ses
 
 /** rct2: 0x008ADD54 */
 static void giga_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7688,7 +7688,7 @@ static void giga_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * se
 
 /** rct2: 0x008ADD64 */
 static void giga_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7730,7 +7730,7 @@ static void giga_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x008ADD74 */
 static void giga_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7772,40 +7772,40 @@ static void giga_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * se
 
 /** rct2: 0x008ADD84 */
 static void giga_rc_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     giga_rc_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008ADD94 */
 static void giga_rc_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     giga_rc_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008ADDA4 */
 static void giga_rc_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     giga_rc_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008ADDB4 */
 static void giga_rc_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     giga_rc_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008ADDC4 */
 static void giga_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7846,7 +7846,7 @@ static void giga_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_sessio
 /** rct2: 0x008ADDD4 */
 static void giga_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7887,7 +7887,7 @@ static void giga_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_sess
 /** rct2: 0x008ADE04 */
 static void giga_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7928,7 +7928,7 @@ static void giga_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_sessio
 /** rct2: 0x008ADE14 */
 static void giga_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7969,42 +7969,42 @@ static void giga_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_sess
 /** rct2: 0x008ADE24 */
 static void giga_rc_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     giga_rc_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008ADE34 */
 static void giga_rc_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     giga_rc_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008ADDE4 */
 static void giga_rc_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     giga_rc_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008ADDF4 */
 static void giga_rc_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     giga_rc_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008ADE44 */
 static void giga_rc_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8046,7 +8046,7 @@ static void giga_rc_track_flat_to_left_banked_25_deg_up(paint_session * session,
 
 /** rct2: 0x008ADE54 */
 static void giga_rc_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8088,7 +8088,7 @@ static void giga_rc_track_flat_to_right_banked_25_deg_up(paint_session * session
 
 /** rct2: 0x008ADE64 */
 static void giga_rc_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8130,7 +8130,7 @@ static void giga_rc_track_left_banked_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x008ADE74 */
 static void giga_rc_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8172,34 +8172,34 @@ static void giga_rc_track_right_banked_25_deg_up_to_flat(paint_session * session
 
 /** rct2: 0x008ADE84 */
 static void giga_rc_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADE94 */
 static void giga_rc_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADEA4 */
 static void giga_rc_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ADEB4 */
 static void giga_rc_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    giga_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    giga_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void giga_rc_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                  rct_tile_element * mapElement)
+                                  rct_tile_element * tileElement)
 {
     // These offsets could be moved to the g2.dat file when that supports offsets.
     sint8 ne_sw_offsetX = 7;
diff --git a/src/openrct2/ride/coaster/HeartlineTwisterCoaster.cpp b/src/openrct2/ride/coaster/HeartlineTwisterCoaster.cpp
index 442f1e5dc9..4b405b7982 100644
--- a/src/openrct2/ride/coaster/HeartlineTwisterCoaster.cpp
+++ b/src/openrct2/ride/coaster/HeartlineTwisterCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x0087694C */
 static void heartline_twister_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -92,7 +92,7 @@ static void heartline_twister_rc_track_flat(paint_session * session, uint8 rideI
 }
 
 static void heartline_twister_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 19732, SPR_STATION_BASE_B_SW_NE },
@@ -106,7 +106,7 @@ static void heartline_twister_rc_track_station(paint_session * session, uint8 ri
     sub_98196C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -114,9 +114,9 @@ static void heartline_twister_rc_track_station(paint_session * session, uint8 ri
 
 /** rct2: 0x0087695C */
 static void heartline_twister_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -198,9 +198,9 @@ static void heartline_twister_rc_track_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008769FC */
 static void heartline_twister_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -282,9 +282,9 @@ static void heartline_twister_rc_track_60_deg_up(paint_session * session, uint8
 
 /** rct2: 0x0087696C */
 static void heartline_twister_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -366,9 +366,9 @@ static void heartline_twister_rc_track_flat_to_25_deg_up(paint_session * session
 
 /** rct2: 0x008769BC */
 static void heartline_twister_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -450,9 +450,9 @@ static void heartline_twister_rc_track_25_deg_up_to_60_deg_up(paint_session * se
 
 /** rct2: 0x008769CC */
 static void heartline_twister_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -534,9 +534,9 @@ static void heartline_twister_rc_track_60_deg_up_to_25_deg_up(paint_session * se
 
 /** rct2: 0x0087697C */
 static void heartline_twister_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -618,51 +618,51 @@ static void heartline_twister_rc_track_25_deg_up_to_flat(paint_session * session
 
 /** rct2: 0x0087698C */
 static void heartline_twister_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    heartline_twister_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    heartline_twister_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00876A0C */
 static void heartline_twister_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    heartline_twister_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    heartline_twister_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0087699C */
 static void heartline_twister_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    heartline_twister_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    heartline_twister_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008769DC */
 static void heartline_twister_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     heartline_twister_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008769EC */
 static void heartline_twister_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     heartline_twister_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008769AC */
 static void heartline_twister_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    heartline_twister_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    heartline_twister_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00876A6C */
 static void heartline_twister_rc_track_heartline_transfer_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -839,7 +839,7 @@ static void heartline_twister_rc_track_heartline_transfer_up(paint_session * ses
 
 /** rct2: 0x00876A7C */
 static void heartline_twister_rc_track_heartline_transfer_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1016,7 +1016,7 @@ static void heartline_twister_rc_track_heartline_transfer_down(paint_session * s
 
 /** rct2: 0x00876A4C */
 static void heartline_twister_rc_track_left_heartline_roll(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1237,7 +1237,7 @@ static void heartline_twister_rc_track_left_heartline_roll(paint_session * sessi
 
 /** rct2: 0x00876A5C */
 static void heartline_twister_rc_track_right_heartline_roll(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
diff --git a/src/openrct2/ride/coaster/InvertedHairpinCoaster.cpp b/src/openrct2/ride/coaster/InvertedHairpinCoaster.cpp
index af71d50c44..4d4ff40210 100644
--- a/src/openrct2/ride/coaster/InvertedHairpinCoaster.cpp
+++ b/src/openrct2/ride/coaster/InvertedHairpinCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x00890CB4 */
 static void inverted_hairpin_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -83,7 +83,7 @@ static void inverted_hairpin_rc_track_flat(paint_session * session, uint8 rideIn
 
 /** rct2: 0x00890D84, 0x00890D94, 0x00890DA4 */
 static void inverted_hairpin_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_STATION_BASE_C_SW_NE, 17028, SPR_STATION_INVERTED_BAR_0_SW_NE },
@@ -99,7 +99,7 @@ static void inverted_hairpin_rc_track_station(paint_session * session, uint8 rid
     sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 1,
                        height + 24, 0, 6, height + 24);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
-    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement, STATION_VARIANT_1);
+    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement, STATION_VARIANT_1);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -107,9 +107,9 @@ static void inverted_hairpin_rc_track_station(paint_session * session, uint8 rid
 
 /** rct2: 0x00890CC4 */
 static void inverted_hairpin_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -192,9 +192,9 @@ static void inverted_hairpin_rc_track_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x00890CD4 */
 static void inverted_hairpin_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -253,9 +253,9 @@ static void inverted_hairpin_rc_track_60_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x00890CE4 */
 static void inverted_hairpin_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -338,9 +338,9 @@ static void inverted_hairpin_rc_track_flat_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x00890CF4 */
 static void inverted_hairpin_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -407,9 +407,9 @@ static void inverted_hairpin_rc_track_25_deg_up_to_60_deg_up(paint_session * ses
 
 /** rct2: 0x00890D04 */
 static void inverted_hairpin_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -500,9 +500,9 @@ static void inverted_hairpin_rc_track_60_deg_up_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x00890D14 */
 static void inverted_hairpin_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -585,51 +585,51 @@ static void inverted_hairpin_rc_track_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x00890D24 */
 static void inverted_hairpin_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_hairpin_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_hairpin_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00890D34 */
 static void inverted_hairpin_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_hairpin_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_hairpin_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00890D44 */
 static void inverted_hairpin_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_hairpin_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_hairpin_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00890D54 */
 static void inverted_hairpin_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     inverted_hairpin_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x00890D64 */
 static void inverted_hairpin_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     inverted_hairpin_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x00890D74 */
 static void inverted_hairpin_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_hairpin_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_hairpin_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00890DB4 */
 static void inverted_hairpin_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -736,16 +736,16 @@ static void inverted_hairpin_rc_track_left_quarter_turn_3(paint_session * sessio
 
 /** rct2: 0x00890DC4 */
 static void inverted_hairpin_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    inverted_hairpin_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_hairpin_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00890DD4 */
 static void inverted_hairpin_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -824,7 +824,7 @@ static void inverted_hairpin_rc_track_left_quarter_turn_3_25_deg_up(paint_sessio
 /** rct2: 0x00890DE4 */
 static void inverted_hairpin_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -903,26 +903,26 @@ static void inverted_hairpin_rc_track_right_quarter_turn_3_25_deg_up(paint_sessi
 /** rct2: 0x00890DF4 */
 static void inverted_hairpin_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     inverted_hairpin_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x00890E04 */
 static void inverted_hairpin_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     inverted_hairpin_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x00890E64 */
 static void inverted_hairpin_rc_track_left_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -967,16 +967,16 @@ static void inverted_hairpin_rc_track_left_quarter_turn_1(paint_session * sessio
 
 /** rct2: 0x00890E74 */
 static void inverted_hairpin_rc_track_right_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_hairpin_rc_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_hairpin_rc_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00890E24 */
 static void inverted_hairpin_rc_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -1043,9 +1043,9 @@ static void inverted_hairpin_rc_track_flat_to_60_deg_up(paint_session * session,
 
 /** rct2: 0x00890E34 */
 static void inverted_hairpin_rc_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -1133,21 +1133,21 @@ static void inverted_hairpin_rc_track_60_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x00890E44 */
 static void inverted_hairpin_rc_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_hairpin_rc_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_hairpin_rc_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00890E54 */
 static void inverted_hairpin_rc_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_hairpin_rc_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_hairpin_rc_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00890E14 */
 static void inverted_hairpin_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1177,7 +1177,7 @@ static void inverted_hairpin_rc_track_brakes(paint_session * session, uint8 ride
 
 /** rct2: 0x00890E84 */
 static void inverted_hairpin_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
diff --git a/src/openrct2/ride/coaster/InvertedImpulseCoaster.cpp b/src/openrct2/ride/coaster/InvertedImpulseCoaster.cpp
index a49184b484..1ae6578c35 100644
--- a/src/openrct2/ride/coaster/InvertedImpulseCoaster.cpp
+++ b/src/openrct2/ride/coaster/InvertedImpulseCoaster.cpp
@@ -28,7 +28,7 @@
 
 /** rct2: 0x008B0460 */
 static void inverted_impulse_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -58,7 +58,7 @@ static void inverted_impulse_rc_track_flat(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008B0470, 0x008B0480, 0x008B0490 */
 static void inverted_impulse_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_STATION_BASE_C_SW_NE, 19662, SPR_STATION_INVERTED_BAR_B_SW_NE },
@@ -74,7 +74,7 @@ static void inverted_impulse_rc_track_station(paint_session * session, uint8 rid
     sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 3,
                        height + 29, 0, 6, height + 29);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
-    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
+    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
                                            STATION_VARIANT_TALL);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -83,7 +83,7 @@ static void inverted_impulse_rc_track_station(paint_session * session, uint8 rid
 
 /** rct2: 0x008B04A0 */
 static void inverted_impulse_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -143,7 +143,7 @@ static void inverted_impulse_rc_track_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008B04B0 */
 static void inverted_impulse_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -179,7 +179,7 @@ static void inverted_impulse_rc_track_60_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008B04C0 */
 static void inverted_impulse_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -236,7 +236,7 @@ static void inverted_impulse_rc_track_flat_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008B04D0 */
 static void inverted_impulse_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -276,7 +276,7 @@ static void inverted_impulse_rc_track_25_deg_up_to_60_deg_up(paint_session * ses
 
 /** rct2: 0x008B04E0 */
 static void inverted_impulse_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -316,7 +316,7 @@ static void inverted_impulse_rc_track_60_deg_up_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x008B04F0 */
 static void inverted_impulse_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -373,51 +373,51 @@ static void inverted_impulse_rc_track_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x008B0500 */
 static void inverted_impulse_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_impulse_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_impulse_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0510 */
 static void inverted_impulse_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_impulse_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_impulse_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0520 */
 static void inverted_impulse_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_impulse_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_impulse_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0530 */
 static void inverted_impulse_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     inverted_impulse_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008B0540 */
 static void inverted_impulse_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     inverted_impulse_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008B0550 */
 static void inverted_impulse_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_impulse_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_impulse_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B05A0 */
 static void inverted_impulse_rc_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -453,14 +453,14 @@ static void inverted_impulse_rc_track_90_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008B05B0 */
 static void inverted_impulse_rc_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_impulse_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_impulse_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0560 */
 static void inverted_impulse_rc_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -500,15 +500,15 @@ static void inverted_impulse_rc_track_60_deg_up_to_90_deg_up(paint_session * ses
 
 /** rct2: 0x008B0570 */
 static void inverted_impulse_rc_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     inverted_impulse_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008B0580 */
 static void inverted_impulse_rc_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -545,7 +545,7 @@ static void inverted_impulse_rc_track_90_deg_up_to_60_deg_up(paint_session * ses
 
 /** rct2: 0x008B0590 */
 static void inverted_impulse_rc_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -585,7 +585,7 @@ static void inverted_impulse_rc_track_60_deg_down_to_90_deg_down(paint_session *
 /** rct2: 0x008B05C0 */
 static void inverted_impulse_rc_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -628,7 +628,7 @@ static void inverted_impulse_rc_track_left_quarter_turn_1_90_deg_up(paint_sessio
 /** rct2: 0x008B05D0 */
 static void inverted_impulse_rc_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -671,19 +671,19 @@ static void inverted_impulse_rc_track_right_quarter_turn_1_90_deg_up(paint_sessi
 /** rct2: 0x008B05E0 */
 static void inverted_impulse_rc_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     inverted_impulse_rc_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x008B05F0 */
 static void inverted_impulse_rc_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     inverted_impulse_rc_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_inverted_impulse_rc(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/coaster/InvertedRollerCoaster.cpp b/src/openrct2/ride/coaster/InvertedRollerCoaster.cpp
index bcecb2f81d..bed35c670d 100644
--- a/src/openrct2/ride/coaster/InvertedRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/InvertedRollerCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008A92E8 */
 static void inverted_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -76,7 +76,7 @@ static void inverted_rc_track_flat(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x008A9558, 0x008A9568, 0x008A9578 */
 static void inverted_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_STATION_BASE_C_SW_NE, 27131, SPR_STATION_INVERTED_BAR_C_SW_NE },
@@ -92,7 +92,7 @@ static void inverted_rc_track_station(paint_session * session, uint8 rideIndex,
     sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 3,
                        height + 29, 0, 6, height + 29);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 3);
-    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
+    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
                                            STATION_VARIANT_TALL);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -101,9 +101,9 @@ static void inverted_rc_track_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A92F8 */
 static void inverted_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -186,7 +186,7 @@ static void inverted_rc_track_25_deg_up(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A9308 */
 static void inverted_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -222,9 +222,9 @@ static void inverted_rc_track_60_deg_up(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A9318 */
 static void inverted_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -307,7 +307,7 @@ static void inverted_rc_track_flat_to_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008A9328 */
 static void inverted_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -347,7 +347,7 @@ static void inverted_rc_track_25_deg_up_to_60_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A9338 */
 static void inverted_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -411,9 +411,9 @@ static void inverted_rc_track_60_deg_up_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A9348 */
 static void inverted_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -496,49 +496,49 @@ static void inverted_rc_track_25_deg_up_to_flat(paint_session * session, uint8 r
 
 /** rct2: 0x008A9358 */
 static void inverted_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9368 */
 static void inverted_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9378 */
 static void inverted_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9388 */
 static void inverted_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9398 */
 static void inverted_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A93A8 */
 static void inverted_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A93B8 */
 static void inverted_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -693,15 +693,15 @@ static void inverted_rc_track_left_quarter_turn_5(paint_session * session, uint8
 
 /** rct2: 0x008A93C8 */
 static void inverted_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    inverted_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A93D8 */
 static void inverted_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -738,7 +738,7 @@ static void inverted_rc_track_flat_to_left_bank(paint_session * session, uint8 r
 
 /** rct2: 0x008A93E8 */
 static void inverted_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -775,7 +775,7 @@ static void inverted_rc_track_flat_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x008A93F8 */
 static void inverted_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -812,7 +812,7 @@ static void inverted_rc_track_left_bank_to_flat(paint_session * session, uint8 r
 
 /** rct2: 0x008A9408 */
 static void inverted_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -849,7 +849,7 @@ static void inverted_rc_track_right_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A9418 */
 static void inverted_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1004,15 +1004,15 @@ static void inverted_rc_track_banked_left_quarter_turn_5(paint_session * session
 
 /** rct2: 0x008A9428 */
 static void inverted_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    inverted_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9438 */
 static void inverted_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1074,7 +1074,7 @@ static void inverted_rc_track_left_bank_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A9448 */
 static void inverted_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1136,7 +1136,7 @@ static void inverted_rc_track_right_bank_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A9458 */
 static void inverted_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1198,7 +1198,7 @@ static void inverted_rc_track_25_deg_up_to_left_bank(paint_session * session, ui
 
 /** rct2: 0x008A9468 */
 static void inverted_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1260,35 +1260,35 @@ static void inverted_rc_track_25_deg_up_to_right_bank(paint_session * session, u
 
 /** rct2: 0x008A9478 */
 static void inverted_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9488 */
 static void inverted_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9498 */
 static void inverted_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A94A8 */
 static void inverted_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A94B8 */
 static void inverted_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1325,14 +1325,14 @@ static void inverted_rc_track_left_bank(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A94C8 */
 static void inverted_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A94D8 */
 static void inverted_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1472,7 +1472,7 @@ static void inverted_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A94E8 */
 static void inverted_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1612,24 +1612,24 @@ static void inverted_rc_track_right_quarter_turn_5_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A94F8 */
 static void inverted_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     inverted_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A9508 */
 static void inverted_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    inverted_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9518 */
 static void inverted_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1779,7 +1779,7 @@ static void inverted_rc_track_s_bend_left(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008A9528 */
 static void inverted_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1929,7 +1929,7 @@ static void inverted_rc_track_s_bend_right(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A9538 */
 static void inverted_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2199,7 +2199,7 @@ static void inverted_rc_track_left_vertical_loop(paint_session * session, uint8
 
 /** rct2: 0x008A9548 */
 static void inverted_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2469,7 +2469,7 @@ static void inverted_rc_track_right_vertical_loop(paint_session * session, uint8
 
 /** rct2: 0x008A9588 */
 static void inverted_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2573,15 +2573,15 @@ static void inverted_rc_track_left_quarter_turn_3(paint_session * session, uint8
 
 /** rct2: 0x008A9598 */
 static void inverted_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    inverted_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A95A8 */
 static void inverted_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2686,15 +2686,15 @@ static void inverted_rc_track_left_quarter_turn_3_bank(paint_session * session,
 
 /** rct2: 0x008A95B8 */
 static void inverted_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    inverted_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A95C8 */
 static void inverted_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2770,7 +2770,7 @@ static void inverted_rc_track_left_quarter_turn_3_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A95D8 */
 static void inverted_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2846,24 +2846,24 @@ static void inverted_rc_track_right_quarter_turn_3_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A95E8 */
 static void inverted_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     inverted_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A95F8 */
 static void inverted_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    inverted_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9608 */
 static void inverted_rc_track_left_twist_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2955,7 +2955,7 @@ static void inverted_rc_track_left_twist_down_to_up(paint_session * session, uin
 
 /** rct2: 0x008A9618 */
 static void inverted_rc_track_right_twist_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3047,7 +3047,7 @@ static void inverted_rc_track_right_twist_down_to_up(paint_session * session, ui
 
 /** rct2: 0x008A9628 */
 static void inverted_rc_track_left_twist_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3139,7 +3139,7 @@ static void inverted_rc_track_left_twist_up_to_down(paint_session * session, uin
 
 /** rct2: 0x008A9638 */
 static void inverted_rc_track_right_twist_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3231,7 +3231,7 @@ static void inverted_rc_track_right_twist_up_to_down(paint_session * session, ui
 
 /** rct2: 0x008A9648 */
 static void inverted_rc_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3366,14 +3366,14 @@ static void inverted_rc_track_half_loop_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A9658 */
 static void inverted_rc_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, mapElement);
+    inverted_rc_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, tileElement);
 }
 
 /** rct2: 0x008A9668 */
 static void inverted_rc_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3476,7 +3476,7 @@ static void inverted_rc_track_left_corkscrew_up(paint_session * session, uint8 r
 
 /** rct2: 0x008A9678 */
 static void inverted_rc_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3579,21 +3579,21 @@ static void inverted_rc_track_right_corkscrew_up(paint_session * session, uint8
 
 /** rct2: 0x008A9688 */
 static void inverted_rc_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, mapElement);
+    inverted_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9698 */
 static void inverted_rc_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A96D8 */
 static void inverted_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3629,7 +3629,7 @@ static void inverted_rc_track_left_quarter_turn_1_60_deg_up(paint_session * sess
 
 /** rct2: 0x008A96B8 */
 static void inverted_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3665,22 +3665,22 @@ static void inverted_rc_track_right_quarter_turn_1_60_deg_up(paint_session * ses
 
 /** rct2: 0x008A96C8 */
 static void inverted_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     inverted_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A96E8 */
 static void inverted_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    inverted_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A96A8 */
 static void inverted_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3709,7 +3709,7 @@ static void inverted_rc_track_brakes(paint_session * session, uint8 rideIndex, u
 
 /** rct2: 0x008A96F8 */
 static void inverted_rc_track_left_quarter_banked_helix_large_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3869,7 +3869,7 @@ static void inverted_rc_track_left_quarter_banked_helix_large_up(paint_session *
 
 /** rct2: 0x008A9708 */
 static void inverted_rc_track_right_quarter_banked_helix_large_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4030,7 +4030,7 @@ static void inverted_rc_track_right_quarter_banked_helix_large_up(paint_session
 /** rct2: 0x008A9718 */
 static void inverted_rc_track_left_quarter_banked_helix_large_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4191,7 +4191,7 @@ static void inverted_rc_track_left_quarter_banked_helix_large_down(paint_session
 /** rct2: 0x008A9728 */
 static void inverted_rc_track_right_quarter_banked_helix_large_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4351,7 +4351,7 @@ static void inverted_rc_track_right_quarter_banked_helix_large_down(paint_sessio
 
 /** rct2: 0x008A9A38 */
 static void inverted_rc_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4411,7 +4411,7 @@ static void inverted_rc_track_25_deg_up_left_banked(paint_session * session, uin
 
 /** rct2: 0x008A9A48 */
 static void inverted_rc_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4471,7 +4471,7 @@ static void inverted_rc_track_25_deg_up_right_banked(paint_session * session, ui
 
 /** rct2: 0x008A9738 */
 static void inverted_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4504,7 +4504,7 @@ static void inverted_rc_track_on_ride_photo(paint_session * session, uint8 rideI
                            height + 29);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_3);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 64, 0x20);
@@ -4512,21 +4512,21 @@ static void inverted_rc_track_on_ride_photo(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A9A58 */
 static void inverted_rc_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9A68 */
 static void inverted_rc_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9748 */
 static void inverted_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4669,7 +4669,7 @@ static void inverted_rc_track_left_eighth_to_diag(paint_session * session, uint8
 
 /** rct2: 0x008A9758 */
 static void inverted_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4812,23 +4812,23 @@ static void inverted_rc_track_right_eighth_to_diag(paint_session * session, uint
 
 /** rct2: 0x008A9768 */
 static void inverted_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    inverted_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9778 */
 static void inverted_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    inverted_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    inverted_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9938 */
 static void inverted_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4972,7 +4972,7 @@ static void inverted_rc_track_left_eighth_bank_to_diag(paint_session * session,
 
 /** rct2: 0x008A9948 */
 static void inverted_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5116,28 +5116,28 @@ static void inverted_rc_track_right_eighth_bank_to_diag(paint_session * session,
 
 /** rct2: 0x008A9958 */
 static void inverted_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    inverted_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9968 */
 static void inverted_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    inverted_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    inverted_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9788 */
 static void inverted_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5162,7 +5162,7 @@ static void inverted_rc_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5187,7 +5187,7 @@ static void inverted_rc_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5212,7 +5212,7 @@ static void inverted_rc_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5262,12 +5262,12 @@ static void inverted_rc_track_diag_flat(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A97B8 */
 static void inverted_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5292,7 +5292,7 @@ static void inverted_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5317,7 +5317,7 @@ static void inverted_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5342,7 +5342,7 @@ static void inverted_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5392,7 +5392,7 @@ static void inverted_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
 
 /** rct2: 0x008A9818 */
 static void inverted_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5470,12 +5470,12 @@ static void inverted_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
 
 /** rct2: 0x008A9798 */
 static void inverted_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5500,7 +5500,7 @@ static void inverted_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5525,7 +5525,7 @@ static void inverted_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5550,7 +5550,7 @@ static void inverted_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5600,7 +5600,7 @@ static void inverted_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A97F8 */
 static void inverted_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5678,7 +5678,7 @@ static void inverted_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
 
 /** rct2: 0x008A9808 */
 static void inverted_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5756,12 +5756,12 @@ static void inverted_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008A97A8 */
 static void inverted_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5786,7 +5786,7 @@ static void inverted_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5811,7 +5811,7 @@ static void inverted_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5836,7 +5836,7 @@ static void inverted_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5886,12 +5886,12 @@ static void inverted_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
 
 /** rct2: 0x008A97E8 */
 static void inverted_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5916,7 +5916,7 @@ static void inverted_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5941,7 +5941,7 @@ static void inverted_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5966,7 +5966,7 @@ static void inverted_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6016,7 +6016,7 @@ static void inverted_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
 
 /** rct2: 0x008A9848 */
 static void inverted_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6094,12 +6094,12 @@ static void inverted_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
 
 /** rct2: 0x008A97C8 */
 static void inverted_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6123,7 +6123,7 @@ static void inverted_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6147,7 +6147,7 @@ static void inverted_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6171,7 +6171,7 @@ static void inverted_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6221,7 +6221,7 @@ static void inverted_rc_track_diag_flat_to_25_deg_down(paint_session * session,
 
 /** rct2: 0x008A9828 */
 static void inverted_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6299,7 +6299,7 @@ static void inverted_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
 
 /** rct2: 0x008A9838 */
 static void inverted_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6377,12 +6377,12 @@ static void inverted_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
 
 /** rct2: 0x008A97D8 */
 static void inverted_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6407,7 +6407,7 @@ static void inverted_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6432,7 +6432,7 @@ static void inverted_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6457,7 +6457,7 @@ static void inverted_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6507,7 +6507,7 @@ static void inverted_rc_track_diag_25_deg_down_to_flat(paint_session * session,
 
 /** rct2: 0x008A9878 */
 static void inverted_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6586,7 +6586,7 @@ static void inverted_rc_track_diag_flat_to_left_bank(paint_session * session, ui
 
 /** rct2: 0x008A9888 */
 static void inverted_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6665,7 +6665,7 @@ static void inverted_rc_track_diag_flat_to_right_bank(paint_session * session, u
 
 /** rct2: 0x008A9898 */
 static void inverted_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6744,7 +6744,7 @@ static void inverted_rc_track_diag_left_bank_to_flat(paint_session * session, ui
 
 /** rct2: 0x008A98A8 */
 static void inverted_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6823,7 +6823,7 @@ static void inverted_rc_track_diag_right_bank_to_flat(paint_session * session, u
 
 /** rct2: 0x008A98D8 */
 static void inverted_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6901,7 +6901,7 @@ static void inverted_rc_track_diag_left_bank_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008A98E8 */
 static void inverted_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6979,7 +6979,7 @@ static void inverted_rc_track_diag_right_bank_to_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008A98B8 */
 static void inverted_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7057,7 +7057,7 @@ static void inverted_rc_track_diag_25_deg_up_to_left_bank(paint_session * sessio
 
 /** rct2: 0x008A98C8 */
 static void inverted_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7135,7 +7135,7 @@ static void inverted_rc_track_diag_25_deg_up_to_right_bank(paint_session * sessi
 
 /** rct2: 0x008A98F8 */
 static void inverted_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7210,7 +7210,7 @@ static void inverted_rc_track_diag_left_bank_to_25_deg_down(paint_session * sess
 
 /** rct2: 0x008A9908 */
 static void inverted_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7285,7 +7285,7 @@ static void inverted_rc_track_diag_right_bank_to_25_deg_down(paint_session * ses
 
 /** rct2: 0x008A9918 */
 static void inverted_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7363,7 +7363,7 @@ static void inverted_rc_track_diag_25_deg_down_to_left_bank(paint_session * sess
 
 /** rct2: 0x008A9928 */
 static void inverted_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7441,7 +7441,7 @@ static void inverted_rc_track_diag_25_deg_down_to_right_bank(paint_session * ses
 
 /** rct2: 0x008A9858 */
 static void inverted_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7520,7 +7520,7 @@ static void inverted_rc_track_diag_left_bank(paint_session * session, uint8 ride
 
 /** rct2: 0x008A9868 */
 static void inverted_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7599,7 +7599,7 @@ static void inverted_rc_track_diag_right_bank(paint_session * session, uint8 rid
 
 /** rct2: 0x008A9978 */
 static void inverted_rc_track_left_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7796,7 +7796,7 @@ static void inverted_rc_track_left_large_half_loop_up(paint_session * session, u
 
 /** rct2: 0x008A9988 */
 static void inverted_rc_track_right_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7993,21 +7993,21 @@ static void inverted_rc_track_right_large_half_loop_up(paint_session * session,
 
 /** rct2: 0x008A9998 */
 static void inverted_rc_track_right_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_right_large_half_loop_up(session, rideIndex, 6 - trackSequence, direction, height, mapElement);
+    inverted_rc_track_right_large_half_loop_up(session, rideIndex, 6 - trackSequence, direction, height, tileElement);
 }
 
 /** rct2: 0x008A99A8 */
 static void inverted_rc_track_left_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_left_large_half_loop_up(session, rideIndex, 6 - trackSequence, direction, height, mapElement);
+    inverted_rc_track_left_large_half_loop_up(session, rideIndex, 6 - trackSequence, direction, height, tileElement);
 }
 
 /** rct2: 0x008A96A8 */
 static void inverted_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8037,7 +8037,7 @@ static void inverted_rc_track_block_brakes(paint_session * session, uint8 rideIn
 /** rct2: 0x008A9A78 */
 static void inverted_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8114,7 +8114,7 @@ static void inverted_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session
 /** rct2: 0x008A9A88 */
 static void inverted_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8191,27 +8191,27 @@ static void inverted_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_sessio
 /** rct2: 0x008A9A98 */
 static void inverted_rc_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     inverted_rc_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008A9AA8 */
 static void inverted_rc_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     inverted_rc_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                           mapElement);
+                                                           tileElement);
 }
 
 /** rct2: 0x008A9BB8 */
 static void inverted_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8352,7 +8352,7 @@ static void inverted_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session
 /** rct2: 0x008A9BC8 */
 static void inverted_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8493,26 +8493,26 @@ static void inverted_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_sessio
 /** rct2: 0x008A9BD8 */
 static void inverted_rc_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     inverted_rc_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008A9BE8 */
 static void inverted_rc_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     inverted_rc_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                           mapElement);
+                                                           tileElement);
 }
 
 /** rct2: 0x008A9AB8 */
 static void inverted_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8572,7 +8572,7 @@ static void inverted_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session *
 
 /** rct2: 0x008A9AC8 */
 static void inverted_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8632,7 +8632,7 @@ static void inverted_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session
 
 /** rct2: 0x008A9AD8 */
 static void inverted_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8692,7 +8692,7 @@ static void inverted_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session *
 
 /** rct2: 0x008A9AE8 */
 static void inverted_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8753,43 +8753,43 @@ static void inverted_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session
 /** rct2: 0x008A9AF8 */
 static void inverted_rc_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     inverted_rc_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x008A9B08 */
 static void inverted_rc_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     inverted_rc_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x008A9B18 */
 static void inverted_rc_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     inverted_rc_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x008A9B28 */
 static void inverted_rc_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     inverted_rc_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x008A9B38 */
 static void inverted_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8850,7 +8850,7 @@ static void inverted_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_se
 /** rct2: 0x008A9B48 */
 static void inverted_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8911,7 +8911,7 @@ static void inverted_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_
 /** rct2: 0x008A9B58 */
 static void inverted_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8972,7 +8972,7 @@ static void inverted_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_se
 /** rct2: 0x008A9B68 */
 static void inverted_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -9033,42 +9033,42 @@ static void inverted_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_
 /** rct2: 0x008A9B78 */
 static void inverted_rc_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     inverted_rc_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3,
-                                                                  height, mapElement);
+                                                                  height, tileElement);
 }
 
 /** rct2: 0x008A9B88 */
 static void inverted_rc_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                             uint8 trackSequence, uint8 direction, sint32 height,
-                                                                            rct_tile_element * mapElement)
+                                                                            rct_tile_element * tileElement)
 {
     inverted_rc_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                mapElement);
+                                                                tileElement);
 }
 
 /** rct2: 0x008A9B98 */
 static void inverted_rc_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     inverted_rc_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3,
-                                                                  height, mapElement);
+                                                                  height, tileElement);
 }
 
 /** rct2: 0x008A9BA8 */
 static void inverted_rc_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                             uint8 trackSequence, uint8 direction, sint32 height,
-                                                                            rct_tile_element * mapElement)
+                                                                            rct_tile_element * tileElement)
 {
     inverted_rc_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                mapElement);
+                                                                tileElement);
 }
 
 /** rct2: 0x008A99B8 */
 static void inverted_rc_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -9128,7 +9128,7 @@ static void inverted_rc_track_flat_to_left_banked_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A99C8 */
 static void inverted_rc_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -9188,7 +9188,7 @@ static void inverted_rc_track_flat_to_right_banked_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A99D8 */
 static void inverted_rc_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -9248,7 +9248,7 @@ static void inverted_rc_track_left_banked_25_deg_up_to_flat(paint_session * sess
 
 /** rct2: 0x008A99E8 */
 static void inverted_rc_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -9308,32 +9308,32 @@ static void inverted_rc_track_right_banked_25_deg_up_to_flat(paint_session * ses
 
 /** rct2: 0x008A99F8 */
 static void inverted_rc_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     inverted_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A9A08 */
 static void inverted_rc_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A9A18 */
 static void inverted_rc_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     inverted_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A9A28 */
 static void inverted_rc_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    inverted_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    inverted_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_inverted_rc(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/coaster/JuniorRollerCoaster.cpp b/src/openrct2/ride/coaster/JuniorRollerCoaster.cpp
index 3f808c4075..f893d2e146 100644
--- a/src/openrct2/ride/coaster/JuniorRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/JuniorRollerCoaster.cpp
@@ -1623,7 +1623,7 @@ static const uint32 junior_rc_track_pieces_diag_60_deg_down_to_25_deg_down[2][4]
 };
 
 void junior_rc_paint_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height,
-                                rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32 imageId = junior_rc_track_pieces_flat[chainType][direction] | session->TrackColours[SCHEME_TRACK];
     sub_98196C_rotated(session, direction, imageId, 0, 6, 32, 20, 1, height);
@@ -1641,11 +1641,11 @@ void junior_rc_paint_track_flat(paint_session * session, uint8 rideIndex, uint8
 }
 
 void junior_rc_paint_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height,
-                             rct_tile_element * mapElement, uint8 rideType)
+                             rct_tile_element * tileElement, uint8 rideType)
 {
     uint32 imageId;
 
-    bool isBraked = (bool)(mapElement->flags & TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED);
+    bool isBraked = (bool)(tileElement->flags & TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED);
 
     if (direction == 0 || direction == 2)
     {
@@ -1654,7 +1654,7 @@ void junior_rc_paint_station(paint_session * session, uint8 rideIndex, uint8 tra
         sub_98197C(session, imageId, 0, 0, 32, 28, 1, height - 2, 0, 2, height, get_current_rotation());
 
         // height += 2 (height)
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && rideType == RIDE_TYPE_JUNIOR_ROLLER_COASTER)
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && rideType == RIDE_TYPE_JUNIOR_ROLLER_COASTER)
         {
             imageId = junior_rc_track_pieces_block_brake[isBraked][direction] | session->TrackColours[SCHEME_TRACK];
         }
@@ -1676,7 +1676,7 @@ void junior_rc_paint_station(paint_session * session, uint8 rideIndex, uint8 tra
         sub_98197C(session, imageId, 0, 0, 28, 32, 1, height - 2, 2, 0, height, get_current_rotation());
 
         // height += 2 (height)
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && rideType == RIDE_TYPE_JUNIOR_ROLLER_COASTER)
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && rideType == RIDE_TYPE_JUNIOR_ROLLER_COASTER)
         {
             imageId = junior_rc_track_pieces_block_brake[isBraked][direction] | session->TrackColours[SCHEME_TRACK];
         }
@@ -1691,14 +1691,14 @@ void junior_rc_paint_station(paint_session * session, uint8 rideIndex, uint8 tra
         paint_util_push_tunnel_right(session, height, TUNNEL_6);
     }
 
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
 }
 
 void junior_rc_paint_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                     uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32 imageId = junior_rc_track_pieces_25_deg_up[chainType][direction] | session->TrackColours[SCHEME_TRACK];
     sub_98196C_rotated(session, direction, imageId, 0, 6, 32, 20, 1, height);
@@ -1719,7 +1719,7 @@ void junior_rc_paint_track_25_deg_up(paint_session * session, uint8 rideIndex, u
 }
 
 void junior_rc_paint_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                             uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32 imageId = junior_rc_track_pieces_flat_to_25_deg_up[chainType][direction] | session->TrackColours[SCHEME_TRACK];
 
@@ -1746,7 +1746,7 @@ void junior_rc_paint_track_flat_to_25_deg_up(paint_session * session, uint8 ride
 }
 
 void junior_rc_paint_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                             uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32 imageId = junior_rc_track_pieces_25_deg_up_to_flat[chainType][direction] | session->TrackColours[SCHEME_TRACK];
     sub_98196C_rotated(session, direction, imageId, 0, 6, 32, 20, 1, height);
@@ -1792,7 +1792,7 @@ static const sint8 junior_rc_track_right_quarter_turn_5_tiles_support_height_off
 };
 
 static void junior_rc_right_quarter_turn_5_tiles_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_5_tiles_paint(
         session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -1867,18 +1867,18 @@ static const uint8 junior_rc_left_quarter_turn_5_tiles_to_right_turn_map[] = { 6
 
 /* rct2: 0x0051917A */
 static void junior_rc_left_quarter_turn_5_tiles_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = junior_rc_left_quarter_turn_5_tiles_to_right_turn_map[trackSequence];
     junior_rc_right_quarter_turn_5_tiles_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /**
  * rct2: 0x008AAFC0, 0x00521593, 0x005216A1, 0x005217AF, 0x00521884
  */
 static void junior_rc_flat_to_left_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
@@ -1926,7 +1926,7 @@ static void junior_rc_flat_to_left_bank_paint_setup(paint_session * session, uin
  * rct2: 0x008AAFD0, 0x00521959, 0x00521A2E, 0x00521B03, 0x00521C11
  */
 static void junior_rc_flat_to_right_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
@@ -1971,15 +1971,15 @@ static void junior_rc_flat_to_right_bank_paint_setup(paint_session * session, ui
 }
 
 static void junior_rc_left_bank_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_flat_to_right_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_flat_to_right_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 static void junior_rc_right_bank_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_flat_to_left_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_flat_to_left_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 const LocationXY16 junior_rc_banked_right_quarter_turn_5_tiles_bound_lengths[4][5] = { {
@@ -2043,7 +2043,7 @@ const LocationXYZ16 junior_rc_banked_right_quarter_turn_5_tiles_bound_offsets[4]
 /* rct2: 0x008AB010, 0x0052304C */
 static void junior_rc_banked_right_quarter_turn_5_tiles_paint_setup(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     uint8 thickness = 1;
     if (direction == 2 && (trackSequence == 0 || trackSequence == 6))
@@ -2133,18 +2133,18 @@ static void junior_rc_banked_right_quarter_turn_5_tiles_paint_setup(paint_sessio
 /* rct2: 0x008AB000 */
 static void junior_rc_banked_left_quarter_turn_5_tiles_paint_setup(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     trackSequence = junior_rc_left_quarter_turn_5_tiles_to_right_turn_map[trackSequence];
     junior_rc_banked_right_quarter_turn_5_tiles_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /**
  * rct2: 0x008AB020, 0x00522073, 0x00522182, 0x00522291, 0x00522367
  */
 static void junior_rc_left_bank_to_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
@@ -2204,7 +2204,7 @@ static void junior_rc_left_bank_to_25_deg_up_paint_setup(paint_session * session
  * rct2: 0x008AB030, 0x0052243D, 0x00522513, 0x005225E9, 0x005226F8
  */
 static void junior_rc_right_bank_to_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
@@ -2264,7 +2264,7 @@ static void junior_rc_right_bank_to_25_deg_up_paint_setup(paint_session * sessio
  * rct2: 0x008AB040, 0x00522807, 0x0052291A, 0x00522A2D, 0x00522B07
  */
 static void junior_rc_25_deg_up_to_left_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
@@ -2325,7 +2325,7 @@ static void junior_rc_25_deg_up_to_left_bank_paint_setup(paint_session * session
  * rct2: 0x008AB050, 0x00522BE1, 0x00522CBB, 0x00522D95, 0x00522EA8
  */
 static void junior_rc_25_deg_up_to_right_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
@@ -2386,36 +2386,36 @@ static void junior_rc_25_deg_up_to_right_bank_paint_setup(paint_session * sessio
  * rct2: 0x008AB060
  */
 static void junior_rc_left_bank_to_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_25_deg_up_to_right_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_25_deg_up_to_right_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /**
  * rct2: 0x008AB070
  */
 static void junior_rc_right_bank_to_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_25_deg_up_to_left_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_25_deg_up_to_left_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /**
  * rct2: 0x008AB080
  */
 static void junior_rc_25_deg_down_to_left_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_right_bank_to_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_right_bank_to_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /**
  * rct2: 0x008AB090
  */
 static void junior_rc_25_deg_down_to_right_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_left_bank_to_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_left_bank_to_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 static const LocationXYZ16 junior_rc_left_bank_bound_lengths[4] = {
@@ -2436,7 +2436,7 @@ static const LocationXY16 junior_rc_left_bank_bound_offsets[4] = {
  * rct2: 0x008AB0A0, 0x00521D1F, 0x00521DF4, 0x00521EC9, 0x00521F9E
  */
 static void junior_rc_left_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
@@ -2471,13 +2471,13 @@ static void junior_rc_left_bank_paint_setup(paint_session * session, uint8 rideI
  * rct2: 0x008AB0B0
  */
 static void junior_rc_right_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_left_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_left_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 void junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                               uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                                JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_right_quarter_turn_5_tiles_paint(session, 1, height, direction, trackSequence,
@@ -2555,7 +2555,7 @@ void junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(paint_session * s
 }
 
 void junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                                uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                                 JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_right_quarter_turn_5_tiles_paint(
@@ -2633,10 +2633,10 @@ void junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(paint_session *
 /* rct2: 0x008AAE10, 0x00519D88, 0x00519DAC, 0x00519DD0, 0x00519DF4 */
 static void junior_rc_left_quarter_turn_5_tiles_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS
                                                                         : JUNIOR_RC_CHAIN_NONE);
 }
@@ -2644,10 +2644,10 @@ static void junior_rc_left_quarter_turn_5_tiles_25_deg_up_paint_setup(paint_sess
 /* rct2: 0x008AAE20, 0x00519E18, 0x0051A148, 0x0051A452, 0x0051A738 */
 static void junior_rc_right_quarter_turn_5_tiles_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                                isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS
                                                                          : JUNIOR_RC_CHAIN_NONE);
 }
@@ -2655,26 +2655,26 @@ static void junior_rc_right_quarter_turn_5_tiles_25_deg_up_paint_setup(paint_ses
 /* rct2: 0x008AAE30, 0x0051AA42, 0x0051AA68, 0x0051AA8C, 0x0051AAB0 */
 static void junior_rc_left_quarter_turn_5_tiles_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     junior_rc_right_quarter_turn_5_tiles_25_deg_up_paint_setup(
         session, rideIndex, junior_rc_left_quarter_turn_5_tiles_to_right_turn_map[trackSequence], (direction + 1) & 3, height,
-        mapElement);
+        tileElement);
 }
 
 /* rct2: 0x008AAE40, 0x0051AAD4, 0x0051AE04, 0x0051B10E, 0x0051B3F4 */
 static void junior_rc_right_quarter_turn_5_tiles_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     junior_rc_left_quarter_turn_5_tiles_25_deg_up_paint_setup(
         session, rideIndex, junior_rc_left_quarter_turn_5_tiles_to_right_turn_map[trackSequence], (direction - 1) & 3, height,
-        mapElement);
+        tileElement);
 }
 
 /* rct2: 0x008AAE50, 0x0051B6FE, 0x0051B946, 0x0051BB8E, 0x0051BBA8 */
 static void junior_rc_s_bend_left_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
@@ -2774,7 +2774,7 @@ static void junior_rc_s_bend_left_paint_setup(paint_session * session, uint8 rid
 
 /* rct2: 0x008AAE60, 0x0051BBC0, 0x0051BE06, 0x0051C04E, 0x0051C068 */
 static void junior_rc_s_bend_right_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
@@ -2874,7 +2874,7 @@ static void junior_rc_s_bend_right_paint_setup(paint_session * session, uint8 ri
 
 /** rct2: 0x008AAEB0, 0x0051C0E0, 0x0051C2C1, 0x0051C47F, 0x0051C61D */
 static void junior_rc_right_quarter_turn_3_tiles_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_3_tiles_paint(
         session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -2912,11 +2912,11 @@ static void junior_rc_right_quarter_turn_3_tiles_paint_setup(paint_session * ses
 
 /** rct2: 0x008AAEA0 */
 static void junior_rc_left_quarter_turn_3_tiles_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     junior_rc_right_quarter_turn_3_tiles_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 const LocationXY16 junior_rc_right_quarter_turn_3_tiles_bank_bound_lengths[4][3] = { {
@@ -2963,7 +2963,7 @@ const LocationXYZ16 junior_rc_right_quarter_turn_3_tiles_bank_offsets[4][3] = {
 
 /** rct2: 0x008AA0D0, 0x00523EA0, 0x005240CC, 0x0052430F, 0x00524500*/
 static void junior_rc_right_quarter_turn_3_tiles_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint8 thickness[4][4] = { { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 26, 1, 1, 26 }, { 1, 1, 1, 1 } };
 
@@ -3013,7 +3013,7 @@ static void junior_rc_right_quarter_turn_3_tiles_bank_paint_setup(paint_session
 }
 
 void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                                uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                                 JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32   imageId      = 0;
@@ -3091,7 +3091,7 @@ void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(paint_session *
 }
 
 void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                                  uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                                   JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32   imageId      = 0;
@@ -3170,20 +3170,20 @@ void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_down(paint_session
 
 /** rct2: 0x008AA0C0 */
 static void junior_rc_left_quarter_turn_3_tiles_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     junior_rc_right_quarter_turn_3_tiles_bank_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x008AAED0, 0x0051C83C, 0x0051C9EC, 0x0051CB76, 0x0051CCDC*/
 static void junior_rc_right_quarter_turn_3_tiles_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                                isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS
                                                                          : JUNIOR_RC_CHAIN_NONE);
 }
@@ -3191,11 +3191,11 @@ static void junior_rc_right_quarter_turn_3_tiles_25_deg_up_paint_setup(paint_ses
 /** rct2: 0x008AAEF0, 0x0051CEC8, 0x0051D078, 0x0051D202, 0x0051D368*/
 static void junior_rc_right_quarter_turn_3_tiles_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
+    bool isChained = track_element_is_lift_hill(tileElement);
     junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_down(
-        session, rideIndex, trackSequence, direction, height, mapElement,
+        session, rideIndex, trackSequence, direction, height, tileElement,
         isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
@@ -3204,27 +3204,27 @@ static const uint8 junior_rc_left_quarter_turn_3_tiles_to_right_turn_map[] = { 3
 /** rct2: 0x008AAEC0 */
 static void junior_rc_left_quarter_turn_3_tiles_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     trackSequence = junior_rc_left_quarter_turn_3_tiles_to_right_turn_map[trackSequence];
     junior_rc_right_quarter_turn_3_tiles_25_deg_down_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                                 mapElement);
+                                                                 tileElement);
 }
 
 /** rct2: 0x008AAEE0 */
 static void junior_rc_left_quarter_turn_3_tiles_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     trackSequence = junior_rc_left_quarter_turn_3_tiles_to_right_turn_map[trackSequence];
     junior_rc_right_quarter_turn_3_tiles_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                               mapElement);
+                                                               tileElement);
 }
 
 /** rct2: 0x008AB0F0, 0x0052B3A4, 0x0052B5F8, 0x0052B863, 0x0052BA78 */
 static void junior_rc_right_half_banked_helix_up_small_paint_setup(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     const sint8 thickness[2] = { 1, 26 };
 
@@ -3290,7 +3290,7 @@ static void junior_rc_right_half_banked_helix_up_small_paint_setup(paint_session
 /** rct2: 0x008AB110, 0x0052BD80, 0x0052BFD4, 0x0052C23B, 0x0052C450 */
 static void junior_rc_right_half_banked_helix_down_small_paint_setup(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     const sint8 thickness[2] = { 1, 26 };
 
@@ -3355,7 +3355,7 @@ static void junior_rc_right_half_banked_helix_down_small_paint_setup(paint_sessi
 
 /** rct2: 0x008AB0E0 */
 static void junior_rc_left_half_banked_helix_up_small_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence > 3)
     {
@@ -3365,13 +3365,13 @@ static void junior_rc_left_half_banked_helix_up_small_paint_setup(paint_session
     }
     trackSequence = junior_rc_left_quarter_turn_3_tiles_to_right_turn_map[trackSequence];
     junior_rc_right_half_banked_helix_down_small_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x008AB100 */
 static void junior_rc_left_half_banked_helix_down_small_paint_setup(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     if (trackSequence > 3)
     {
@@ -3381,13 +3381,13 @@ static void junior_rc_left_half_banked_helix_down_small_paint_setup(paint_sessio
     }
     trackSequence = junior_rc_left_quarter_turn_3_tiles_to_right_turn_map[trackSequence];
     junior_rc_right_half_banked_helix_up_small_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                           mapElement);
+                                                           tileElement);
 }
 
 /** rct2: 0x008AB130, 0x0052C7BC, 0x0052CB6B, 0x0052CF32, 0x0052D2B3 */
 static void junior_rc_right_half_banked_helix_up_large_paint_setup(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     const sint8 thickness[2] = { 1, 26 };
 
@@ -3469,7 +3469,7 @@ static void junior_rc_right_half_banked_helix_up_large_paint_setup(paint_session
 /** rct2: 0x008AB150, 0x0052D778, 0x0052DB27, 0x0052DEEA, 0x0052E26B */
 static void junior_rc_right_half_banked_helix_down_large_paint_setup(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     const sint8 thickness[2] = { 1, 26 };
 
@@ -3550,7 +3550,7 @@ static void junior_rc_right_half_banked_helix_down_large_paint_setup(paint_sessi
 
 /** rct2: 0x008AB120 */
 static void junior_rc_left_half_banked_helix_up_large_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence > 6)
     {
@@ -3560,13 +3560,13 @@ static void junior_rc_left_half_banked_helix_up_large_paint_setup(paint_session
     }
     trackSequence = junior_rc_left_quarter_turn_5_tiles_to_right_turn_map[trackSequence];
     junior_rc_right_half_banked_helix_down_large_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x008AB140 */
 static void junior_rc_left_half_banked_helix_down_large_paint_setup(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     if (trackSequence > 6)
     {
@@ -3576,14 +3576,14 @@ static void junior_rc_left_half_banked_helix_down_large_paint_setup(paint_sessio
     }
     trackSequence = junior_rc_left_quarter_turn_5_tiles_to_right_turn_map[trackSequence];
     junior_rc_right_half_banked_helix_up_large_paint_setup(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                           mapElement);
+                                                           tileElement);
 }
 
 /**
  * rct2: 0x008AAF00, 0x0051851C, 0x005185D8
  */
 static void junior_rc_brake_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
@@ -3617,11 +3617,11 @@ static void junior_rc_brake_paint_setup(paint_session * session, uint8 rideIndex
  * rct2: 0x008AB280, 0x00518694, 0x00518759
  */
 static void junior_rc_block_brake_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id;
 
-    bool isBraked = (bool)(mapElement->flags & TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED);
+    bool isBraked = (bool)(tileElement->flags & TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED);
 
     image_id = junior_rc_track_pieces_block_brake[isBraked][direction] | session->TrackColours[SCHEME_TRACK];
     if (direction & 1)
@@ -3651,7 +3651,7 @@ static void junior_rc_block_brake_paint_setup(paint_session * session, uint8 rid
 
 /** rct2: 0x008AAF80 */
 static void junior_rc_left_eighth_to_diag_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_eighth_to_diag_tiles_paint(session, defaultEighthToDiagThickness, height, direction, trackSequence,
                                                 session->TrackColours[SCHEME_TRACK], junior_rc_track_pieces_left_eight_to_diag,
@@ -3713,7 +3713,7 @@ static void junior_rc_left_eighth_to_diag_paint_setup(paint_session * session, u
 
 /** rct2: 0x008AAF90 */
 static void junior_rc_right_eighth_to_diag_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_eighth_to_diag_tiles_paint(session, defaultEighthToDiagThickness, height, direction, trackSequence,
                                                 session->TrackColours[SCHEME_TRACK], junior_rc_track_pieces_right_eight_to_diag,
@@ -3775,20 +3775,20 @@ static void junior_rc_right_eighth_to_diag_paint_setup(paint_session * session,
 
 /** rct2: 0x008AAFA0 */
 static void junior_rc_left_eighth_to_orthogonal_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint8 map[] = { 4, 2, 3, 1, 0 };
     trackSequence     = map[trackSequence];
-    junior_rc_right_eighth_to_diag_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_right_eighth_to_diag_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008AAFB0 */
 static void junior_rc_right_eighth_to_orthogonal_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint8 map[] = { 4, 2, 3, 1, 0 };
     trackSequence     = map[trackSequence];
-    junior_rc_left_eighth_to_diag_paint_setup(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
+    junior_rc_left_eighth_to_diag_paint_setup(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 static const LocationXY16 junior_rc_left_eighth_to_diag_bank_bound_lengths[4][4] = {
@@ -3874,7 +3874,7 @@ static const sint8 junior_rc_left_eighth_to_diag_bank_thickness[4][4] = {
 
 /** rct2: 0x008AB160 */
 static void junior_rc_left_eighth_to_diag_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_eighth_to_diag_tiles_paint(session, junior_rc_left_eighth_to_diag_bank_thickness, height, direction,
                                                 trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4018,7 +4018,7 @@ static const sint8 junior_rc_right_eighth_to_diag_bank_thickness[4][4] = {
 
 /** rct2: 0x008AB170 */
 static void junior_rc_right_eighth_to_diag_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_eighth_to_diag_tiles_paint(session, junior_rc_right_eighth_to_diag_bank_thickness, height, direction,
                                                 trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4081,20 +4081,20 @@ static void junior_rc_right_eighth_to_diag_bank_paint_setup(paint_session * sess
 
 /** rct2: 0x008AB180 */
 static void junior_rc_left_eighth_to_orthogonal_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint8 map[] = { 4, 2, 3, 1, 0 };
     trackSequence     = map[trackSequence];
-    junior_rc_right_eighth_to_diag_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_right_eighth_to_diag_bank_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008AB190 */
 static void junior_rc_right_eighth_to_orthogonal_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint8 map[] = { 4, 2, 3, 1, 0 };
     trackSequence     = map[trackSequence];
-    junior_rc_left_eighth_to_diag_bank_paint_setup(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
+    junior_rc_left_eighth_to_diag_bank_paint_setup(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 static const sint32 junior_rc_diag_blocked_segments[] = { SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4 | SEGMENT_BC,
@@ -4105,7 +4105,7 @@ static const sint32 junior_rc_diag_blocked_segments[] = { SEGMENT_C4 | SEGMENT_C
 static const uint8 junior_rc_diag_support_segment[] = { 1, 0, 2, 3 };
 
 void junior_rc_paint_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                     uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_flat[chainType], defaultDiagTileOffsets,
@@ -4124,7 +4124,7 @@ void junior_rc_paint_track_diag_flat(paint_session * session, uint8 rideIndex, u
 }
 
 void junior_rc_paint_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                          uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_25_deg_up[chainType], defaultDiagTileOffsets,
@@ -4142,7 +4142,7 @@ void junior_rc_paint_track_diag_25_deg_up(paint_session * session, uint8 rideInd
 }
 
 void junior_rc_paint_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                  uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                   JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4161,7 +4161,7 @@ void junior_rc_paint_track_diag_flat_to_25_deg_up(paint_session * session, uint8
 }
 
 void junior_rc_paint_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                  uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                   JUNIOR_RC_CHAINTYPE chainType)
 {
     // There is no specific chain for the Water Coaster, use the Junior RC chain instead
@@ -4183,7 +4183,7 @@ void junior_rc_paint_track_diag_flat_to_60_deg_up(paint_session * session, uint8
 }
 
 void junior_rc_paint_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                  uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                   JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4202,7 +4202,7 @@ void junior_rc_paint_track_diag_25_deg_up_to_flat(paint_session * session, uint8
 }
 
 void junior_rc_paint_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                  uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                   JUNIOR_RC_CHAINTYPE chainType)
 {
     // There is no specific chain for the Water Coaster, use the Junior RC chain instead
@@ -4224,7 +4224,7 @@ void junior_rc_paint_track_diag_60_deg_up_to_flat(paint_session * session, uint8
 }
 
 void junior_rc_paint_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                            uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
 
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4243,7 +4243,7 @@ void junior_rc_paint_track_diag_25_deg_down(paint_session * session, uint8 rideI
 }
 
 void junior_rc_paint_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                    uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                     JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4262,7 +4262,7 @@ void junior_rc_paint_track_diag_flat_to_25_deg_down(paint_session * session, uin
 }
 
 void junior_rc_paint_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                    uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                     JUNIOR_RC_CHAINTYPE chainType)
 {
     // There is no specific chain for the Water Coaster, use the Junior RC chain instead
@@ -4284,7 +4284,7 @@ void junior_rc_paint_track_diag_flat_to_60_deg_down(paint_session * session, uin
 }
 
 void junior_rc_paint_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                    uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                     JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4303,7 +4303,7 @@ void junior_rc_paint_track_diag_25_deg_down_to_flat(paint_session * session, uin
 }
 
 void junior_rc_paint_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                    uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                     JUNIOR_RC_CHAINTYPE chainType)
 {
     // There is no specific chain for the Water Coaster, use the Junior RC chain instead
@@ -4326,102 +4326,102 @@ void junior_rc_paint_track_diag_60_deg_down_to_flat(paint_session * session, uin
 
 /** rct2: 0x008AAF10 */
 static void junior_rc_diag_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                     isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /** rct2: 0x008AAF40 */
 static void junior_rc_diag_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                          isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /** rct2: 0x008AAF20 */
 static void junior_rc_diag_flat_to_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_flat_to_60_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /** rct2: 0x008AAF30 */
 static void junior_rc_diag_25_deg_up_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_60_deg_up_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /** rct2: 0x008AAF70 */
 static void junior_rc_diag_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                            isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /** rct2: 0x008AAF50 */
 static void junior_rc_diag_flat_to_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                    isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_flat_to_60_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_flat_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_flat_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                    isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /** rct2: 0x008AAF60 */
 static void junior_rc_diag_25_deg_down_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                    isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_60_deg_down_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_60_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_60_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                    isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /** rct2: 0x008AB1C0 */
 static void junior_rc_diag_flat_to_left_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_flat_to_left_bank, defaultDiagTileOffsets,
@@ -4447,7 +4447,7 @@ static void junior_rc_diag_flat_to_left_bank_paint_setup(paint_session * session
 
 /** rct2: 0x008AB1D0 */
 static void junior_rc_diag_flat_to_right_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_flat_to_right_bank, defaultDiagTileOffsets,
@@ -4473,7 +4473,7 @@ static void junior_rc_diag_flat_to_right_bank_paint_setup(paint_session * sessio
 
 /** rct2: 0x008AB1E0 */
 static void junior_rc_diag_left_bank_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_left_bank_to_flat, defaultDiagTileOffsets,
@@ -4499,7 +4499,7 @@ static void junior_rc_diag_left_bank_to_flat_paint_setup(paint_session * session
 
 /** rct2: 0x008AB1F0 */
 static void junior_rc_diag_right_bank_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_right_bank_to_flat, defaultDiagTileOffsets,
@@ -4525,7 +4525,7 @@ static void junior_rc_diag_right_bank_to_flat_paint_setup(paint_session * sessio
 
 /** rct2: 0x008AB220 */
 static void junior_rc_diag_left_bank_to_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_left_bank_to_25_deg_up, defaultDiagTileOffsets,
@@ -4550,7 +4550,7 @@ static void junior_rc_diag_left_bank_to_25_deg_up_paint_setup(paint_session * se
 
 /** rct2: 0x008AB230 */
 static void junior_rc_diag_right_bank_to_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_right_bank_to_25_deg_up, defaultDiagTileOffsets,
@@ -4575,7 +4575,7 @@ static void junior_rc_diag_right_bank_to_25_deg_up_paint_setup(paint_session * s
 
 /** rct2: 0x008AB200 */
 static void junior_rc_diag_25_deg_up_to_left_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_25_deg_up_to_left_bank, defaultDiagTileOffsets,
@@ -4600,7 +4600,7 @@ static void junior_rc_diag_25_deg_up_to_left_bank_paint_setup(paint_session * se
 
 /** rct2: 0x008AB210 */
 static void junior_rc_diag_25_deg_up_to_right_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_25_deg_up_to_right_bank, defaultDiagTileOffsets,
@@ -4625,7 +4625,7 @@ static void junior_rc_diag_25_deg_up_to_right_bank_paint_setup(paint_session * s
 
 /** rct2: 0x008AB200 */
 static void junior_rc_diag_left_bank_to_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_left_bank_to_25_deg_down, defaultDiagTileOffsets,
@@ -4650,7 +4650,7 @@ static void junior_rc_diag_left_bank_to_25_deg_down_paint_setup(paint_session *
 
 /** rct2: 0x008AB210 */
 static void junior_rc_diag_right_bank_to_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_right_bank_to_25_deg_down, defaultDiagTileOffsets,
@@ -4675,7 +4675,7 @@ static void junior_rc_diag_right_bank_to_25_deg_down_paint_setup(paint_session *
 
 /** rct2: 0x008AB220 */
 static void junior_rc_diag_25_deg_down_to_left_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_25_deg_down_to_left_bank, defaultDiagTileOffsets,
@@ -4700,7 +4700,7 @@ static void junior_rc_diag_25_deg_down_to_left_bank_paint_setup(paint_session *
 
 /** rct2: 0x008AB230 */
 static void junior_rc_diag_25_deg_down_to_right_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_25_deg_down_to_right_bank, defaultDiagTileOffsets,
@@ -4739,7 +4739,7 @@ const LocationXYZ16 junior_rc_diag_right_bank_bound_offsets[4] = {
 
 /** rct2: 0x008AB1A0 */
 static void junior_rc_diag_left_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     uint8 thickness = direction == 0 ? 0 : 1;
     track_paint_util_diag_tiles_paint(session, thickness, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4760,7 +4760,7 @@ static void junior_rc_diag_left_bank_paint_setup(paint_session * session, uint8
 
 /** rct2: 0x008AB1B0 */
 static void junior_rc_diag_right_bank_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint8 thickness = direction == 2 ? 0 : 1;
     track_paint_util_diag_tiles_paint(session, thickness, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -4803,7 +4803,7 @@ static const LocationXY16 junior_rc_60_deg_up_bound_lengths[4] = {
 };
 
 void junior_rc_paint_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                     uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32 image_id = session->TrackColours[SCHEME_TRACK];
 
@@ -4846,17 +4846,17 @@ void junior_rc_paint_track_60_deg_up(paint_session * session, uint8 rideIndex, u
 }
 
 static void junior_rc_60_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                     isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_60_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_60_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_60_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 static const LocationXY16 junior_rc_25_deg_up_to_60_deg_up_bound_lengths[4][2] = {
@@ -4876,7 +4876,7 @@ static const LocationXY16 junior_rc_25_deg_up_to_60_deg_up_bound_offsets[4][2] =
 };
 
 void junior_rc_paint_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                  uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                   JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32 image_id = session->TrackColours[SCHEME_TRACK];
@@ -4937,21 +4937,21 @@ void junior_rc_paint_track_25_deg_up_to_60_deg_up(paint_session * session, uint8
 }
 
 static void junior_rc_25_deg_up_to_60_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_60_deg_down_to_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_25_deg_up_to_60_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_25_deg_up_to_60_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 void junior_rc_paint_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                  uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                   JUNIOR_RC_CHAINTYPE chainType)
 {
     uint32 image_id = session->TrackColours[SCHEME_TRACK];
@@ -5011,21 +5011,21 @@ void junior_rc_paint_track_60_deg_up_to_25_deg_up(paint_session * session, uint8
 }
 
 static void junior_rc_60_deg_up_to_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_25_deg_down_to_60_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_60_deg_up_to_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    junior_rc_60_deg_up_to_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 void junior_rc_paint_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                          uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_60_deg_up[chainType], defaultDiagTileOffsets,
@@ -5043,7 +5043,7 @@ void junior_rc_paint_track_diag_60_deg_up(paint_session * session, uint8 rideInd
 }
 
 void junior_rc_paint_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            uint16 height, rct_tile_element * mapElement, JUNIOR_RC_CHAINTYPE chainType)
+                                            uint16 height, rct_tile_element * tileElement, JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
                                       junior_rc_track_pieces_diag_60_deg_down[chainType], defaultDiagTileOffsets,
@@ -5061,7 +5061,7 @@ void junior_rc_paint_track_diag_60_deg_down(paint_session * session, uint8 rideI
 }
 
 void junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                       uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                        JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -5080,7 +5080,7 @@ void junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(paint_session * session,
 }
 
 void junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                       uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                        JUNIOR_RC_CHAINTYPE chainType)
 {
     if (direction == 1 && trackSequence == 3)
@@ -5109,7 +5109,7 @@ void junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(paint_session * session,
 }
 
 void junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                           uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                            JUNIOR_RC_CHAINTYPE chainType)
 {
     if (direction == 3 && trackSequence == 0)
@@ -5138,7 +5138,7 @@ void junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(paint_session * sessi
 }
 
 void junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, uint16 height, rct_tile_element * mapElement,
+                                                           uint8 direction, uint16 height, rct_tile_element * tileElement,
                                                            JUNIOR_RC_CHAINTYPE chainType)
 {
     track_paint_util_diag_tiles_paint(session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -5157,50 +5157,50 @@ void junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(paint_session * sessi
 }
 
 static void junior_rc_diag_60_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                          isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_60_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                            isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_25_deg_up_to_60_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_60_deg_up_to_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_25_deg_down_to_60_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void junior_rc_diag_60_deg_down_to_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
@@ -5229,11 +5229,11 @@ static const LocationXY16 junior_rc_60_deg_up_to_flat_tile_offsets[4][2] = {
 };
 
 static void junior_rc_flat_to_60_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id = session->TrackColours[SCHEME_TRACK];
 
-    bool isChained = mapElement->type & (1 << 7);
+    bool isChained = tileElement->type & (1 << 7);
 
     image_id |= junior_rc_track_pieces_flat_to_60_deg_up[isChained][direction][0];
 
@@ -5291,18 +5291,18 @@ static void junior_rc_flat_to_60_deg_up_paint_setup(paint_session * session, uin
 }
 
 static void junior_rc_60_deg_down_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_flat_to_60_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    junior_rc_flat_to_60_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void junior_rc_60_deg_up_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
 
     uint32 image_id = session->TrackColours[SCHEME_TRACK];
 
-    bool isChained = mapElement->type & (1 << 7);
+    bool isChained = tileElement->type & (1 << 7);
 
     image_id |= junior_rc_track_pieces_60_deg_up_to_flat[isChained][direction][0];
 
@@ -5359,80 +5359,80 @@ static void junior_rc_60_deg_up_to_flat_paint_setup(paint_session * session, uin
 }
 
 static void junior_rc_flat_to_60_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_60_deg_up_to_flat_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    junior_rc_60_deg_up_to_flat_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /* rct2: 0x00518394 */
 static void junior_rc_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /* rct2: 0x00515629, 0x00514D22, 0x005151B9 */
 static void paint_junior_rc_station_track(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_station(session, rideIndex, trackSequence, direction, height, mapElement, RIDE_TYPE_JUNIOR_ROLLER_COASTER);
+    junior_rc_paint_station(session, rideIndex, trackSequence, direction, height, tileElement, RIDE_TYPE_JUNIOR_ROLLER_COASTER);
 }
 
 /* rct2: 0x0051881E */
 static void junior_rc_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                     isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /* rct2: 0x00518B42 */
 static void junior_rc_flat_to_25_deg_up_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                             isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /* rct2: 0x00518E56 */
 static void junior_rc_25_deg_up_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                             isChained ? JUNIOR_RC_CHAIN_FRICTION_WHEELS : JUNIOR_RC_CHAIN_NONE);
 }
 
 /* rct2: 0x005189B0 */
 static void junior_rc_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
 
-    junior_rc_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    junior_rc_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /* rct2: 0x00518FE8 */
 static void junior_rc_flat_to_25_deg_down_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
 
-    junior_rc_25_deg_up_to_flat_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    junior_rc_25_deg_up_to_flat_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /* rct2: 0x00518CCC */
 static void junior_rc_25_deg_down_to_flat_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
 
-    junior_rc_flat_to_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    junior_rc_flat_to_25_deg_up_paint_setup(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void junior_rc_booster_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     sint32 XoffsetNESW = 12;
     sint32 YoffsetNESW = -10;
diff --git a/src/openrct2/ride/coaster/JuniorRollerCoaster.h b/src/openrct2/ride/coaster/JuniorRollerCoaster.h
index 7252e7bb2e..88416d9ee3 100644
--- a/src/openrct2/ride/coaster/JuniorRollerCoaster.h
+++ b/src/openrct2/ride/coaster/JuniorRollerCoaster.h
@@ -27,38 +27,38 @@ typedef enum JUNIOR_RC_CHAINTYPE
     JUNIOR_RC_CHAIN_CHAIN_LIFT,
 } JUNIOR_RC_CHAINTYPE;
 
-void junior_rc_paint_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, uint8 rideType);
+void junior_rc_paint_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, uint8 rideType);
 
-void junior_rc_paint_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
 
-void junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
 
-void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
 
-void junior_rc_paint_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
-void junior_rc_paint_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* mapElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
+void junior_rc_paint_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element* tileElement, JUNIOR_RC_CHAINTYPE chainType);
 
 #endif // _JUNIOR_ROLLER_COASTER_H
diff --git a/src/openrct2/ride/coaster/LayDownRollerCoaster.cpp b/src/openrct2/ride/coaster/LayDownRollerCoaster.cpp
index 3933e5872e..39824ae5dc 100644
--- a/src/openrct2/ride/coaster/LayDownRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/LayDownRollerCoaster.cpp
@@ -28,11 +28,11 @@
 
 /** rct2: 0x0082491C */
 static void lay_down_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -87,7 +87,7 @@ static void lay_down_rc_track_flat(paint_session * session, uint8 rideIndex, uin
     }
     else
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -135,9 +135,9 @@ static void lay_down_rc_track_flat(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x00824B8C, 0x00824B9C, 0x00824BAC */
 static void lay_down_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_inverted(mapElement))
+    if (track_element_is_inverted(tileElement))
     {
         static const uint32 imageIds[4][3] = {
             { SPR_STATION_BASE_C_SW_NE, 26557, SPR_STATION_INVERTED_BAR_A_SW_NE },
@@ -153,7 +153,7 @@ static void lay_down_rc_track_station(paint_session * session, uint8 rideIndex,
         sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 1,
                            height + 24, 0, 6, height + 24);
         track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
-        track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
+        track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
                                                STATION_VARIANT_1);
         paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
     }
@@ -166,7 +166,7 @@ static void lay_down_rc_track_station(paint_session * session, uint8 rideIndex,
             { 16237, 16233, SPR_STATION_BASE_A_NW_SE },
         };
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
         {
             sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20,
                                1, height, 0, 6, height + 3);
@@ -179,7 +179,7 @@ static void lay_down_rc_track_station(paint_session * session, uint8 rideIndex,
         sub_98196C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                            height);
         track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 11);
-        track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+        track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
         paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     }
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -188,11 +188,11 @@ static void lay_down_rc_track_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x0082492C */
 static void lay_down_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -260,7 +260,7 @@ static void lay_down_rc_track_25_deg_up(paint_session * session, uint8 rideIndex
     }
     else
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -344,11 +344,11 @@ static void lay_down_rc_track_25_deg_up(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x0082493C */
 static void lay_down_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -451,11 +451,11 @@ static void lay_down_rc_track_60_deg_up(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x0082494C */
 static void lay_down_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -523,7 +523,7 @@ static void lay_down_rc_track_flat_to_25_deg_up(paint_session * session, uint8 r
     }
     else
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -607,11 +607,11 @@ static void lay_down_rc_track_flat_to_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x0082495C */
 static void lay_down_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -726,11 +726,11 @@ static void lay_down_rc_track_25_deg_up_to_60_deg_up(paint_session * session, ui
 
 /** rct2: 0x0082496C */
 static void lay_down_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -869,11 +869,11 @@ static void lay_down_rc_track_60_deg_up_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x0082497C */
 static void lay_down_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -941,7 +941,7 @@ static void lay_down_rc_track_25_deg_up_to_flat(paint_session * session, uint8 r
     }
     else
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1025,51 +1025,51 @@ static void lay_down_rc_track_25_deg_up_to_flat(paint_session * session, uint8 r
 
 /** rct2: 0x0082498C */
 static void lay_down_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0082499C */
 static void lay_down_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008249AC */
 static void lay_down_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008249BC */
 static void lay_down_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008249CC */
 static void lay_down_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008249DC */
 static void lay_down_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008249EC */
 static void lay_down_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -1389,17 +1389,17 @@ static void lay_down_rc_track_left_quarter_turn_5(paint_session * session, uint8
 
 /** rct2: 0x008249FC */
 static void lay_down_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    lay_down_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    lay_down_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824A0C */
 static void lay_down_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1473,9 +1473,9 @@ static void lay_down_rc_track_flat_to_left_bank(paint_session * session, uint8 r
 
 /** rct2: 0x00824A1C */
 static void lay_down_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1549,9 +1549,9 @@ static void lay_down_rc_track_flat_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x00824A2C */
 static void lay_down_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1625,9 +1625,9 @@ static void lay_down_rc_track_left_bank_to_flat(paint_session * session, uint8 r
 
 /** rct2: 0x00824A3C */
 static void lay_down_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1701,9 +1701,9 @@ static void lay_down_rc_track_right_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x00824A4C */
 static void lay_down_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -2027,17 +2027,17 @@ static void lay_down_rc_track_banked_left_quarter_turn_5(paint_session * session
 
 /** rct2: 0x00824A5C */
 static void lay_down_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    lay_down_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    lay_down_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824A6C */
 static void lay_down_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2142,9 +2142,9 @@ static void lay_down_rc_track_left_bank_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x00824A7C */
 static void lay_down_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2249,9 +2249,9 @@ static void lay_down_rc_track_right_bank_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x00824A8C */
 static void lay_down_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2356,9 +2356,9 @@ static void lay_down_rc_track_25_deg_up_to_left_bank(paint_session * session, ui
 
 /** rct2: 0x00824A9C */
 static void lay_down_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2463,37 +2463,37 @@ static void lay_down_rc_track_25_deg_up_to_right_bank(paint_session * session, u
 
 /** rct2: 0x00824AAC */
 static void lay_down_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824ABC */
 static void lay_down_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824ACC */
 static void lay_down_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824ADC */
 static void lay_down_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824AEC */
 static void lay_down_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2563,16 +2563,16 @@ static void lay_down_rc_track_left_bank(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x00824AFC */
 static void lay_down_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824B0C */
 static void lay_down_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -2887,9 +2887,9 @@ static void lay_down_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sess
 
 /** rct2: 0x00824B1C */
 static void lay_down_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3204,26 +3204,26 @@ static void lay_down_rc_track_right_quarter_turn_5_25_deg_up(paint_session * ses
 
 /** rct2: 0x00824B2C */
 static void lay_down_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     lay_down_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x00824B3C */
 static void lay_down_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    lay_down_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    lay_down_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824B4C */
 static void lay_down_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3511,9 +3511,9 @@ static void lay_down_rc_track_s_bend_left(paint_session * session, uint8 rideInd
 
 /** rct2: 0x00824B5C */
 static void lay_down_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3801,9 +3801,9 @@ static void lay_down_rc_track_s_bend_right(paint_session * session, uint8 rideIn
 
 /** rct2: 0x00824B6C */
 static void lay_down_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4309,9 +4309,9 @@ static void lay_down_rc_track_left_vertical_loop(paint_session * session, uint8
 
 /** rct2: 0x00824B7C */
 static void lay_down_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4727,9 +4727,9 @@ static void lay_down_rc_track_right_vertical_loop(paint_session * session, uint8
 
 /** rct2: 0x00824BBC */
 static void lay_down_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4935,17 +4935,17 @@ static void lay_down_rc_track_left_quarter_turn_3(paint_session * session, uint8
 
 /** rct2: 0x00824BCC */
 static void lay_down_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    lay_down_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    lay_down_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824BDC */
 static void lay_down_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5155,17 +5155,17 @@ static void lay_down_rc_track_left_quarter_turn_3_bank(paint_session * session,
 
 /** rct2: 0x00824BEC */
 static void lay_down_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    lay_down_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    lay_down_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824BFC */
 static void lay_down_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5321,9 +5321,9 @@ static void lay_down_rc_track_left_quarter_turn_3_25_deg_up(paint_session * sess
 
 /** rct2: 0x00824C0C */
 static void lay_down_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5485,26 +5485,26 @@ static void lay_down_rc_track_right_quarter_turn_3_25_deg_up(paint_session * ses
 
 /** rct2: 0x00824C1C */
 static void lay_down_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     lay_down_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x00824C2C */
 static void lay_down_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    lay_down_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    lay_down_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824C9C */
 static void lay_down_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5912,9 +5912,9 @@ static void lay_down_rc_track_left_half_banked_helix_up_small(paint_session * se
 
 /** rct2: 0x00824CAC */
 static void lay_down_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -6322,7 +6322,7 @@ static void lay_down_rc_track_right_half_banked_helix_up_small(paint_session * s
 
 /** rct2: 0x00824CBC */
 static void lay_down_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -6331,12 +6331,12 @@ static void lay_down_rc_track_left_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     lay_down_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x00824CCC */
 static void lay_down_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -6345,14 +6345,14 @@ static void lay_down_rc_track_right_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     lay_down_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x00824CDC */
 static void lay_down_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -6988,9 +6988,9 @@ static void lay_down_rc_track_left_half_banked_helix_up_large(paint_session * se
 
 /** rct2: 0x00824CEC */
 static void lay_down_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -7626,7 +7626,7 @@ static void lay_down_rc_track_right_half_banked_helix_up_large(paint_session * s
 
 /** rct2: 0x00824CFC */
 static void lay_down_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -7635,12 +7635,12 @@ static void lay_down_rc_track_left_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     lay_down_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x00824D0C */
 static void lay_down_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -7649,14 +7649,14 @@ static void lay_down_rc_track_right_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     lay_down_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x00824D3C */
 static void lay_down_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -7723,9 +7723,9 @@ static void lay_down_rc_track_left_quarter_turn_1_60_deg_up(paint_session * sess
 
 /** rct2: 0x00824D1C */
 static void lay_down_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -7793,24 +7793,24 @@ static void lay_down_rc_track_right_quarter_turn_1_60_deg_up(paint_session * ses
 
 /** rct2: 0x00824D2C */
 static void lay_down_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     lay_down_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x00824D4C */
 static void lay_down_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    lay_down_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824D5C */
 static void lay_down_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -7866,9 +7866,9 @@ static void lay_down_rc_track_brakes(paint_session * session, uint8 rideIndex, u
 
 /** rct2: 0x00824D6C */
 static void lay_down_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -7909,7 +7909,7 @@ static void lay_down_rc_track_on_ride_photo(paint_session * session, uint8 rideI
                                height + 3);
             break;
         }
-        track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+        track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
         paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_0);
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -7955,7 +7955,7 @@ static void lay_down_rc_track_on_ride_photo(paint_session * session, uint8 rideI
                                6, height + 24);
             break;
         }
-        track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+        track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
         paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_0);
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         paint_util_set_general_support_height(session, height + 64, 0x20);
@@ -7964,9 +7964,9 @@ static void lay_down_rc_track_on_ride_photo(paint_session * session, uint8 rideI
 
 /** rct2: 0x00824D8C */
 static void lay_down_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8241,9 +8241,9 @@ static void lay_down_rc_track_left_eighth_to_diag(paint_session * session, uint8
 
 /** rct2: 0x00824D9C */
 static void lay_down_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8518,25 +8518,25 @@ static void lay_down_rc_track_right_eighth_to_diag(paint_session * session, uint
 
 /** rct2: 0x00824DAC */
 static void lay_down_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    lay_down_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824DBC */
 static void lay_down_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    lay_down_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    lay_down_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824DCC */
 static void lay_down_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8811,9 +8811,9 @@ static void lay_down_rc_track_left_eighth_bank_to_diag(paint_session * session,
 
 /** rct2: 0x00824DDC */
 static void lay_down_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -9088,30 +9088,30 @@ static void lay_down_rc_track_right_eighth_bank_to_diag(paint_session * session,
 
 /** rct2: 0x00824DEC */
 static void lay_down_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    lay_down_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lay_down_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824DFC */
 static void lay_down_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    lay_down_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    lay_down_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x00824D7C */
 static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9136,7 +9136,7 @@ static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9161,7 +9161,7 @@ static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9186,7 +9186,7 @@ static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9245,7 +9245,7 @@ static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9270,7 +9270,7 @@ static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9295,7 +9295,7 @@ static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9320,7 +9320,7 @@ static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9371,14 +9371,14 @@ static void lay_down_rc_track_diag_flat(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x00824E2C */
 static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9403,7 +9403,7 @@ static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9428,7 +9428,7 @@ static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9453,7 +9453,7 @@ static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9512,7 +9512,7 @@ static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9537,7 +9537,7 @@ static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9562,7 +9562,7 @@ static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9587,7 +9587,7 @@ static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9638,14 +9638,14 @@ static void lay_down_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
 
 /** rct2: 0x00824E8C */
 static void lay_down_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9670,7 +9670,7 @@ static void lay_down_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9695,7 +9695,7 @@ static void lay_down_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9720,7 +9720,7 @@ static void lay_down_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9853,14 +9853,14 @@ static void lay_down_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
 
 /** rct2: 0x00824E0C */
 static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9885,7 +9885,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9910,7 +9910,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9935,7 +9935,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9994,7 +9994,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10019,7 +10019,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10044,7 +10044,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10069,7 +10069,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10120,14 +10120,14 @@ static void lay_down_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x00824E6C */
 static void lay_down_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10152,7 +10152,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10177,7 +10177,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10202,7 +10202,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10335,14 +10335,14 @@ static void lay_down_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
 
 /** rct2: 0x00824E7C */
 static void lay_down_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10367,7 +10367,7 @@ static void lay_down_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10392,7 +10392,7 @@ static void lay_down_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10417,7 +10417,7 @@ static void lay_down_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10550,14 +10550,14 @@ static void lay_down_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x00824E1C */
 static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10582,7 +10582,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10607,7 +10607,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10632,7 +10632,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10691,7 +10691,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10716,7 +10716,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10741,7 +10741,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10766,7 +10766,7 @@ static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10817,14 +10817,14 @@ static void lay_down_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
 
 /** rct2: 0x00824E5C */
 static void lay_down_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10849,7 +10849,7 @@ static void lay_down_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10874,7 +10874,7 @@ static void lay_down_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -10899,7 +10899,7 @@ static void lay_down_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11032,14 +11032,14 @@ static void lay_down_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
 
 /** rct2: 0x00824EBC */
 static void lay_down_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11064,7 +11064,7 @@ static void lay_down_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11089,7 +11089,7 @@ static void lay_down_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11114,7 +11114,7 @@ static void lay_down_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 104, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11247,14 +11247,14 @@ static void lay_down_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
 
 /** rct2: 0x00824E3C */
 static void lay_down_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11278,7 +11278,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_down(paint_session * session,
                 session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11302,7 +11302,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_down(paint_session * session,
                 session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11326,7 +11326,7 @@ static void lay_down_rc_track_diag_flat_to_25_deg_down(paint_session * session,
                 session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11455,14 +11455,14 @@ static void lay_down_rc_track_diag_flat_to_25_deg_down(paint_session * session,
 
 /** rct2: 0x00824E9C */
 static void lay_down_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11487,7 +11487,7 @@ static void lay_down_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11512,7 +11512,7 @@ static void lay_down_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11537,7 +11537,7 @@ static void lay_down_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11670,14 +11670,14 @@ static void lay_down_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
 
 /** rct2: 0x00824EAC */
 static void lay_down_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11702,7 +11702,7 @@ static void lay_down_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11727,7 +11727,7 @@ static void lay_down_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11752,7 +11752,7 @@ static void lay_down_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
             paint_util_set_general_support_height(session, height + 72, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11885,14 +11885,14 @@ static void lay_down_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
 
 /** rct2: 0x00824E4C */
 static void lay_down_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11917,7 +11917,7 @@ static void lay_down_rc_track_diag_25_deg_down_to_flat(paint_session * session,
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11942,7 +11942,7 @@ static void lay_down_rc_track_diag_25_deg_down_to_flat(paint_session * session,
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -11967,7 +11967,7 @@ static void lay_down_rc_track_diag_25_deg_down_to_flat(paint_session * session,
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -12100,9 +12100,9 @@ static void lay_down_rc_track_diag_25_deg_down_to_flat(paint_session * session,
 
 /** rct2: 0x00824EEC */
 static void lay_down_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12252,9 +12252,9 @@ static void lay_down_rc_track_diag_flat_to_left_bank(paint_session * session, ui
 
 /** rct2: 0x00824EFC */
 static void lay_down_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12404,9 +12404,9 @@ static void lay_down_rc_track_diag_flat_to_right_bank(paint_session * session, u
 
 /** rct2: 0x00824F0C */
 static void lay_down_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12556,9 +12556,9 @@ static void lay_down_rc_track_diag_left_bank_to_flat(paint_session * session, ui
 
 /** rct2: 0x00824F1C */
 static void lay_down_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12708,9 +12708,9 @@ static void lay_down_rc_track_diag_right_bank_to_flat(paint_session * session, u
 
 /** rct2: 0x00824F4C */
 static void lay_down_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12859,9 +12859,9 @@ static void lay_down_rc_track_diag_left_bank_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x00824F5C */
 static void lay_down_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13010,9 +13010,9 @@ static void lay_down_rc_track_diag_right_bank_to_25_deg_up(paint_session * sessi
 
 /** rct2: 0x00824F2C */
 static void lay_down_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13161,9 +13161,9 @@ static void lay_down_rc_track_diag_25_deg_up_to_left_bank(paint_session * sessio
 
 /** rct2: 0x00824F3C */
 static void lay_down_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13312,9 +13312,9 @@ static void lay_down_rc_track_diag_25_deg_up_to_right_bank(paint_session * sessi
 
 /** rct2: 0x00824F6C */
 static void lay_down_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13456,9 +13456,9 @@ static void lay_down_rc_track_diag_left_bank_to_25_deg_down(paint_session * sess
 
 /** rct2: 0x00824F7C */
 static void lay_down_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13600,9 +13600,9 @@ static void lay_down_rc_track_diag_right_bank_to_25_deg_down(paint_session * ses
 
 /** rct2: 0x00824F8C */
 static void lay_down_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13751,9 +13751,9 @@ static void lay_down_rc_track_diag_25_deg_down_to_left_bank(paint_session * sess
 
 /** rct2: 0x00824F9C */
 static void lay_down_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13902,9 +13902,9 @@ static void lay_down_rc_track_diag_25_deg_down_to_right_bank(paint_session * ses
 
 /** rct2: 0x00824ECC */
 static void lay_down_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14052,9 +14052,9 @@ static void lay_down_rc_track_diag_left_bank(paint_session * session, uint8 ride
 
 /** rct2: 0x00824EDC */
 static void lay_down_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14202,9 +14202,9 @@ static void lay_down_rc_track_diag_right_bank(paint_session * session, uint8 rid
 
 /** rct2: 0x00824FAC */
 static void lay_down_rc_track_left_flyer_twist_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14412,9 +14412,9 @@ static void lay_down_rc_track_left_flyer_twist_up(paint_session * session, uint8
 
 /** rct2: 0x00824FBC */
 static void lay_down_rc_track_right_flyer_twist_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14622,9 +14622,9 @@ static void lay_down_rc_track_right_flyer_twist_up(paint_session * session, uint
 
 /** rct2: 0x00824FCC */
 static void lay_down_rc_track_left_flyer_twist_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -14832,9 +14832,9 @@ static void lay_down_rc_track_left_flyer_twist_down(paint_session * session, uin
 
 /** rct2: 0x00824FDC */
 static void lay_down_rc_track_right_flyer_twist_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15042,9 +15042,9 @@ static void lay_down_rc_track_right_flyer_twist_down(paint_session * session, ui
 
 /** rct2: 0x00824C3C */
 static void lay_down_rc_track_flyer_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15278,9 +15278,9 @@ static void lay_down_rc_track_flyer_half_loop_up(paint_session * session, uint8
 
 /** rct2: 0x00824C4C */
 static void lay_down_rc_track_flyer_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15514,9 +15514,9 @@ static void lay_down_rc_track_flyer_half_loop_down(paint_session * session, uint
 
 /** rct2: 0x00824C5C */
 static void lay_down_rc_track_left_flyer_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15742,9 +15742,9 @@ static void lay_down_rc_track_left_flyer_corkscrew_up(paint_session * session, u
 
 /** rct2: 0x00824C6C */
 static void lay_down_rc_track_right_flyer_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -15944,9 +15944,9 @@ static void lay_down_rc_track_right_flyer_corkscrew_up(paint_session * session,
 
 /** rct2: 0x00824C7C */
 static void lay_down_rc_track_left_flyer_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -16146,16 +16146,16 @@ static void lay_down_rc_track_left_flyer_corkscrew_down(paint_session * session,
 
 /** rct2: 0x00824C8C */
 static void lay_down_rc_track_right_flyer_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lay_down_rc_track_left_flyer_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 3) % 4, height, mapElement);
+    lay_down_rc_track_left_flyer_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 /** rct2: 0x00824FEC */
 static void lay_down_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -16207,7 +16207,7 @@ static void lay_down_rc_track_block_brakes(paint_session * session, uint8 rideIn
 }
 
 static void lay_down_rc_track_left_quarter_banked_helix_large_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -16368,7 +16368,7 @@ static void lay_down_rc_track_left_quarter_banked_helix_large_up(paint_session *
 }
 
 static void lay_down_rc_track_right_quarter_banked_helix_large_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -16530,7 +16530,7 @@ static void lay_down_rc_track_right_quarter_banked_helix_large_up(paint_session
 
 static void lay_down_rc_track_left_quarter_banked_helix_large_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -16692,7 +16692,7 @@ static void lay_down_rc_track_left_quarter_banked_helix_large_down(paint_session
 
 static void lay_down_rc_track_right_quarter_banked_helix_large_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
diff --git a/src/openrct2/ride/coaster/LimLaunchedRollerCoaster.cpp b/src/openrct2/ride/coaster/LimLaunchedRollerCoaster.cpp
index 5fd623218b..f03b9d1b5d 100644
--- a/src/openrct2/ride/coaster/LimLaunchedRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/LimLaunchedRollerCoaster.cpp
@@ -28,7 +28,7 @@
 
 /** rct2: 0x008A6D50, 0x008A6D60, 0x008A6D70 */
 static void lim_launched_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 15018, 15020, SPR_STATION_BASE_B_SW_NE },
@@ -37,7 +37,7 @@ static void lim_launched_rc_track_station(paint_session * session, uint8 rideInd
         { 15019, 15021, SPR_STATION_BASE_B_NW_SE },
     };
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20, 1,
                            height, 0, 6, height + 3);
@@ -50,7 +50,7 @@ static void lim_launched_rc_track_station(paint_session * session, uint8 rideInd
     sub_98196C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -58,7 +58,7 @@ static void lim_launched_rc_track_station(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008A65E0 */
 static void lim_launched_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -274,7 +274,7 @@ static void lim_launched_rc_track_left_vertical_loop(paint_session * session, ui
 
 /** rct2: 0x008A65F0 */
 static void lim_launched_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -458,7 +458,7 @@ static void lim_launched_rc_track_right_vertical_loop(paint_session * session, u
 
 /** rct2: 0x008A6D10 */
 static void lim_launched_rc_track_left_twist_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -581,7 +581,7 @@ static void lim_launched_rc_track_left_twist_down_to_up(paint_session * session,
 
 /** rct2: 0x008A6D20 */
 static void lim_launched_rc_track_right_twist_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -704,7 +704,7 @@ static void lim_launched_rc_track_right_twist_down_to_up(paint_session * session
 
 /** rct2: 0x008A6D30 */
 static void lim_launched_rc_track_left_twist_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -827,7 +827,7 @@ static void lim_launched_rc_track_left_twist_up_to_down(paint_session * session,
 
 /** rct2: 0x008A6D40 */
 static void lim_launched_rc_track_right_twist_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -950,7 +950,7 @@ static void lim_launched_rc_track_right_twist_up_to_down(paint_session * session
 
 /** rct2: 0x008A6CD0 */
 static void lim_launched_rc_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1048,7 +1048,7 @@ static void lim_launched_rc_track_left_corkscrew_up(paint_session * session, uin
 
 /** rct2: 0x008A6CE0 */
 static void lim_launched_rc_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1147,21 +1147,21 @@ static void lim_launched_rc_track_right_corkscrew_up(paint_session * session, ui
 
 /** rct2: 0x008A6CF0 */
 static void lim_launched_rc_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lim_launched_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, mapElement);
+    lim_launched_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6D00 */
 static void lim_launched_rc_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lim_launched_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, mapElement);
+    lim_launched_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6D80 */
 static void lim_launched_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1188,7 +1188,7 @@ static void lim_launched_rc_track_brakes(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A6C10 */
 static void lim_launched_rc_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1224,14 +1224,14 @@ static void lim_launched_rc_track_90_deg_up(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A6C20 */
 static void lim_launched_rc_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    lim_launched_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lim_launched_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6C30 */
 static void lim_launched_rc_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1271,14 +1271,14 @@ static void lim_launched_rc_track_60_deg_up_to_90_deg_up(paint_session * session
 
 /** rct2: 0x008A6C40 */
 static void lim_launched_rc_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    lim_launched_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    lim_launched_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6C50 */
 static void lim_launched_rc_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1315,7 +1315,7 @@ static void lim_launched_rc_track_90_deg_up_to_60_deg_up(paint_session * session
 
 /** rct2: 0x008A6C60 */
 static void lim_launched_rc_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1355,7 +1355,7 @@ static void lim_launched_rc_track_60_deg_down_to_90_deg_down(paint_session * ses
 /** rct2: 0x008A6C70 */
 static void lim_launched_rc_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1441,15 +1441,15 @@ static void lim_launched_rc_track_90_deg_to_inverted_flat_quarter_loop_up(paint_
 /** rct2: 0x008A6C80 */
 static void lim_launched_rc_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex,
                                                                             uint8 trackSequence, uint8 direction, sint32 height,
-                                                                            rct_tile_element * mapElement)
+                                                                            rct_tile_element * tileElement)
 {
     lim_launched_rc_track_90_deg_to_inverted_flat_quarter_loop_up(session, rideIndex, 2 - trackSequence, direction, height,
-                                                                  mapElement);
+                                                                  tileElement);
 }
 
 /** rct2: 0x008A6D90 */
 static void lim_launched_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1475,7 +1475,7 @@ static void lim_launched_rc_track_block_brakes(paint_session * session, uint8 ri
 }
 
 static void lim_launched_rc_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1515,7 +1515,7 @@ static void lim_launched_rc_track_left_quarter_turn_1_90_deg_up(paint_session *
 
 /** rct2: 0x008A6CA0 */
 static void lim_launched_rc_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1555,19 +1555,19 @@ static void lim_launched_rc_track_right_quarter_turn_1_90_deg_up(paint_session *
 
 /** rct2: 0x008A6CB0 */
 static void lim_launched_rc_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     lim_launched_rc_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x008A6CC0 */
 static void lim_launched_rc_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     lim_launched_rc_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_lim_launched_rc(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/coaster/LoopingRollerCoaster.cpp b/src/openrct2/ride/coaster/LoopingRollerCoaster.cpp
index d28c110436..6b83d8f3fc 100644
--- a/src/openrct2/ride/coaster/LoopingRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/LoopingRollerCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008A6370 */
 static void looping_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                  rct_tile_element * mapElement)
+                                  rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -83,7 +83,7 @@ static void looping_rc_track_flat(paint_session * session, uint8 rideIndex, uint
 }
 
 static void looping_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { 15016, SPR_STATION_BASE_B_SW_NE },
@@ -97,7 +97,7 @@ static void looping_rc_track_station(paint_session * session, uint8 rideIndex, u
     sub_98196C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -105,9 +105,9 @@ static void looping_rc_track_station(paint_session * session, uint8 rideIndex, u
 
 /** rct2: 0x008A6380 */
 static void looping_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -174,9 +174,9 @@ static void looping_rc_track_25_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A6390 */
 static void looping_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -243,9 +243,9 @@ static void looping_rc_track_60_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A63A0 */
 static void looping_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -312,9 +312,9 @@ static void looping_rc_track_flat_to_25_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x008A63B0 */
 static void looping_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -389,9 +389,9 @@ static void looping_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uin
 
 /** rct2: 0x008A63C0 */
 static void looping_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -466,9 +466,9 @@ static void looping_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x008A63D0 */
 static void looping_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -535,49 +535,49 @@ static void looping_rc_track_25_deg_up_to_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x008A63E0 */
 static void looping_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A63F0 */
 static void looping_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6400 */
 static void looping_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6410 */
 static void looping_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6420 */
 static void looping_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6430 */
 static void looping_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6440 */
 static void looping_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -731,15 +731,15 @@ static void looping_rc_track_left_quarter_turn_5(paint_session * session, uint8
 
 /** rct2: 0x008A6450 */
 static void looping_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    looping_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    looping_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6460 */
 static void looping_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -776,7 +776,7 @@ static void looping_rc_track_flat_to_left_bank(paint_session * session, uint8 ri
 
 /** rct2: 0x008A6470 */
 static void looping_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -813,7 +813,7 @@ static void looping_rc_track_flat_to_right_bank(paint_session * session, uint8 r
 
 /** rct2: 0x008A6480 */
 static void looping_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -850,7 +850,7 @@ static void looping_rc_track_left_bank_to_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x008A6490 */
 static void looping_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -887,7 +887,7 @@ static void looping_rc_track_right_bank_to_flat(paint_session * session, uint8 r
 
 /** rct2: 0x008A64A0 */
 static void looping_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1045,15 +1045,15 @@ static void looping_rc_track_banked_left_quarter_turn_5(paint_session * session,
 
 /** rct2: 0x008A64B0 */
 static void looping_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    looping_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    looping_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A64C0 */
 static void looping_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1097,7 +1097,7 @@ static void looping_rc_track_left_bank_to_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x008A64D0 */
 static void looping_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1141,7 +1141,7 @@ static void looping_rc_track_right_bank_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A64E0 */
 static void looping_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1185,7 +1185,7 @@ static void looping_rc_track_25_deg_up_to_left_bank(paint_session * session, uin
 
 /** rct2: 0x008A64F0 */
 static void looping_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1229,35 +1229,35 @@ static void looping_rc_track_25_deg_up_to_right_bank(paint_session * session, ui
 
 /** rct2: 0x008A6500 */
 static void looping_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6510 */
 static void looping_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6520 */
 static void looping_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6530 */
 static void looping_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6540 */
 static void looping_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1290,14 +1290,14 @@ static void looping_rc_track_left_bank(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A6550 */
 static void looping_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6560 */
 static void looping_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1446,7 +1446,7 @@ static void looping_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008A6570 */
 static void looping_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1595,23 +1595,23 @@ static void looping_rc_track_right_quarter_turn_5_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A6580 */
 static void looping_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    looping_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    looping_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6590 */
 static void looping_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    looping_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    looping_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A65A0 */
 static void looping_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1735,7 +1735,7 @@ static void looping_rc_track_s_bend_left(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A65B0 */
 static void looping_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1859,7 +1859,7 @@ static void looping_rc_track_s_bend_right(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008A65C0 */
 static void looping_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2097,7 +2097,7 @@ static void looping_rc_track_left_vertical_loop(paint_session * session, uint8 r
 
 /** rct2: 0x008A65D0 */
 static void looping_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2309,7 +2309,7 @@ static void looping_rc_track_right_vertical_loop(paint_session * session, uint8
 
 /** rct2: 0x008A6630 */
 static void looping_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2408,15 +2408,15 @@ static void looping_rc_track_left_quarter_turn_3(paint_session * session, uint8
 
 /** rct2: 0x008A6640 */
 static void looping_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    looping_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    looping_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6650 */
 static void looping_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2519,15 +2519,15 @@ static void looping_rc_track_left_quarter_turn_3_bank(paint_session * session, u
 
 /** rct2: 0x008A6660 */
 static void looping_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    looping_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    looping_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6670 */
 static void looping_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2597,7 +2597,7 @@ static void looping_rc_track_left_quarter_turn_3_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008A6680 */
 static void looping_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2670,23 +2670,23 @@ static void looping_rc_track_right_quarter_turn_3_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A6690 */
 static void looping_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    looping_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    looping_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A66A0 */
 static void looping_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    looping_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    looping_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A66B0 */
 static void looping_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2887,7 +2887,7 @@ static void looping_rc_track_left_half_banked_helix_up_small(paint_session * ses
 
 /** rct2: 0x008A66C0 */
 static void looping_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3088,7 +3088,7 @@ static void looping_rc_track_right_half_banked_helix_up_small(paint_session * se
 
 /** rct2: 0x008A66D0 */
 static void looping_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -3097,12 +3097,12 @@ static void looping_rc_track_left_half_banked_helix_down_small(paint_session * s
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     looping_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A66E0 */
 static void looping_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -3111,12 +3111,12 @@ static void looping_rc_track_right_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     looping_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A66F0 */
 static void looping_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3427,7 +3427,7 @@ static void looping_rc_track_left_half_banked_helix_up_large(paint_session * ses
 
 /** rct2: 0x008A6700 */
 static void looping_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3738,7 +3738,7 @@ static void looping_rc_track_right_half_banked_helix_up_large(paint_session * se
 
 /** rct2: 0x008A6710 */
 static void looping_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3747,12 +3747,12 @@ static void looping_rc_track_left_half_banked_helix_down_large(paint_session * s
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     looping_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A6720 */
 static void looping_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3761,12 +3761,12 @@ static void looping_rc_track_right_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     looping_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A6750 */
 static void looping_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3802,7 +3802,7 @@ static void looping_rc_track_left_quarter_turn_1_60_deg_up(paint_session * sessi
 
 /** rct2: 0x008A6730 */
 static void looping_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3838,21 +3838,21 @@ static void looping_rc_track_right_quarter_turn_1_60_deg_up(paint_session * sess
 
 /** rct2: 0x008A6740 */
 static void looping_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    looping_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6760 */
 static void looping_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    looping_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6770 */
 static void looping_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3883,7 +3883,7 @@ static void looping_rc_track_brakes(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008A6A40 */
 static void looping_rc_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3923,7 +3923,7 @@ static void looping_rc_track_25_deg_up_left_banked(paint_session * session, uint
 
 /** rct2: 0x008A6A50 */
 static void looping_rc_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3963,7 +3963,7 @@ static void looping_rc_track_25_deg_up_right_banked(paint_session * session, uin
 
 /** rct2: 0x008A6780 */
 static void looping_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4000,7 +4000,7 @@ static void looping_rc_track_on_ride_photo(paint_session * session, uint8 rideIn
                            height + 3);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_0);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -4008,21 +4008,21 @@ static void looping_rc_track_on_ride_photo(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A6A60 */
 static void looping_rc_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6A70 */
 static void looping_rc_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6860 */
 static void looping_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4146,7 +4146,7 @@ static void looping_rc_track_left_eighth_to_diag(paint_session * session, uint8
 
 /** rct2: 0x008A6870 */
 static void looping_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4270,23 +4270,23 @@ static void looping_rc_track_right_eighth_to_diag(paint_session * session, uint8
 
 /** rct2: 0x008A6880 */
 static void looping_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    looping_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6890 */
 static void looping_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    looping_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    looping_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A68A0 */
 static void looping_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4410,7 +4410,7 @@ static void looping_rc_track_left_eighth_bank_to_diag(paint_session * session, u
 
 /** rct2: 0x008A68B0 */
 static void looping_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4534,28 +4534,28 @@ static void looping_rc_track_right_eighth_bank_to_diag(paint_session * session,
 
 /** rct2: 0x008A68C0 */
 static void looping_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    looping_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A68D0 */
 static void looping_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    looping_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    looping_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6790 */
 static void looping_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4580,7 +4580,7 @@ static void looping_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4605,7 +4605,7 @@ static void looping_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4630,7 +4630,7 @@ static void looping_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4687,12 +4687,12 @@ static void looping_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A67C0 */
 static void looping_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4717,7 +4717,7 @@ static void looping_rc_track_diag_25_deg_up(paint_session * session, uint8 rideI
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4742,7 +4742,7 @@ static void looping_rc_track_diag_25_deg_up(paint_session * session, uint8 rideI
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4767,7 +4767,7 @@ static void looping_rc_track_diag_25_deg_up(paint_session * session, uint8 rideI
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4824,12 +4824,12 @@ static void looping_rc_track_diag_25_deg_up(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A67F0 */
 static void looping_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4854,7 +4854,7 @@ static void looping_rc_track_diag_60_deg_up(paint_session * session, uint8 rideI
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4879,7 +4879,7 @@ static void looping_rc_track_diag_60_deg_up(paint_session * session, uint8 rideI
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4904,7 +4904,7 @@ static void looping_rc_track_diag_60_deg_up(paint_session * session, uint8 rideI
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4961,12 +4961,12 @@ static void looping_rc_track_diag_60_deg_up(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A67A0 */
 static void looping_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4991,7 +4991,7 @@ static void looping_rc_track_diag_flat_to_25_deg_up(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5016,7 +5016,7 @@ static void looping_rc_track_diag_flat_to_25_deg_up(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5041,7 +5041,7 @@ static void looping_rc_track_diag_flat_to_25_deg_up(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5098,12 +5098,12 @@ static void looping_rc_track_diag_flat_to_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x008A67D0 */
 static void looping_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5128,7 +5128,7 @@ static void looping_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5153,7 +5153,7 @@ static void looping_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5178,7 +5178,7 @@ static void looping_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5235,12 +5235,12 @@ static void looping_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session
 
 /** rct2: 0x008A67E0 */
 static void looping_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5265,7 +5265,7 @@ static void looping_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5290,7 +5290,7 @@ static void looping_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5315,7 +5315,7 @@ static void looping_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5372,12 +5372,12 @@ static void looping_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session
 
 /** rct2: 0x008A67B0 */
 static void looping_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5402,7 +5402,7 @@ static void looping_rc_track_diag_25_deg_up_to_flat(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5427,7 +5427,7 @@ static void looping_rc_track_diag_25_deg_up_to_flat(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5452,7 +5452,7 @@ static void looping_rc_track_diag_25_deg_up_to_flat(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5509,12 +5509,12 @@ static void looping_rc_track_diag_25_deg_up_to_flat(paint_session * session, uin
 
 /** rct2: 0x008A6820 */
 static void looping_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5539,7 +5539,7 @@ static void looping_rc_track_diag_25_deg_down(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5564,7 +5564,7 @@ static void looping_rc_track_diag_25_deg_down(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5589,7 +5589,7 @@ static void looping_rc_track_diag_25_deg_down(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5646,12 +5646,12 @@ static void looping_rc_track_diag_25_deg_down(paint_session * session, uint8 rid
 
 /** rct2: 0x008A6850 */
 static void looping_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5676,7 +5676,7 @@ static void looping_rc_track_diag_60_deg_down(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5701,7 +5701,7 @@ static void looping_rc_track_diag_60_deg_down(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5726,7 +5726,7 @@ static void looping_rc_track_diag_60_deg_down(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5783,12 +5783,12 @@ static void looping_rc_track_diag_60_deg_down(paint_session * session, uint8 rid
 
 /** rct2: 0x008A6800 */
 static void looping_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5812,7 +5812,7 @@ static void looping_rc_track_diag_flat_to_25_deg_down(paint_session * session, u
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5836,7 +5836,7 @@ static void looping_rc_track_diag_flat_to_25_deg_down(paint_session * session, u
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5860,7 +5860,7 @@ static void looping_rc_track_diag_flat_to_25_deg_down(paint_session * session, u
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5918,12 +5918,12 @@ static void looping_rc_track_diag_flat_to_25_deg_down(paint_session * session, u
 
 /** rct2: 0x008A6830 */
 static void looping_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5948,7 +5948,7 @@ static void looping_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5973,7 +5973,7 @@ static void looping_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5998,7 +5998,7 @@ static void looping_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6055,12 +6055,12 @@ static void looping_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * ses
 
 /** rct2: 0x008A6840 */
 static void looping_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6085,7 +6085,7 @@ static void looping_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6110,7 +6110,7 @@ static void looping_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6135,7 +6135,7 @@ static void looping_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6192,12 +6192,12 @@ static void looping_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * ses
 
 /** rct2: 0x008A6810 */
 static void looping_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6222,7 +6222,7 @@ static void looping_rc_track_diag_25_deg_down_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6247,7 +6247,7 @@ static void looping_rc_track_diag_25_deg_down_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6272,7 +6272,7 @@ static void looping_rc_track_diag_25_deg_down_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6329,7 +6329,7 @@ static void looping_rc_track_diag_25_deg_down_to_flat(paint_session * session, u
 
 /** rct2: 0x008A6900 */
 static void looping_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6398,7 +6398,7 @@ static void looping_rc_track_diag_flat_to_left_bank(paint_session * session, uin
 
 /** rct2: 0x008A6910 */
 static void looping_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6467,7 +6467,7 @@ static void looping_rc_track_diag_flat_to_right_bank(paint_session * session, ui
 
 /** rct2: 0x008A6920 */
 static void looping_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6536,7 +6536,7 @@ static void looping_rc_track_diag_left_bank_to_flat(paint_session * session, uin
 
 /** rct2: 0x008A6930 */
 static void looping_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6605,7 +6605,7 @@ static void looping_rc_track_diag_right_bank_to_flat(paint_session * session, ui
 
 /** rct2: 0x008A6960 */
 static void looping_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6674,7 +6674,7 @@ static void looping_rc_track_diag_left_bank_to_25_deg_up(paint_session * session
 
 /** rct2: 0x008A6970 */
 static void looping_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6743,7 +6743,7 @@ static void looping_rc_track_diag_right_bank_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008A6940 */
 static void looping_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6812,7 +6812,7 @@ static void looping_rc_track_diag_25_deg_up_to_left_bank(paint_session * session
 
 /** rct2: 0x008A6950 */
 static void looping_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6881,7 +6881,7 @@ static void looping_rc_track_diag_25_deg_up_to_right_bank(paint_session * sessio
 
 /** rct2: 0x008A6980 */
 static void looping_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6948,7 +6948,7 @@ static void looping_rc_track_diag_left_bank_to_25_deg_down(paint_session * sessi
 
 /** rct2: 0x008A6990 */
 static void looping_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7015,7 +7015,7 @@ static void looping_rc_track_diag_right_bank_to_25_deg_down(paint_session * sess
 
 /** rct2: 0x008A69A0 */
 static void looping_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7084,7 +7084,7 @@ static void looping_rc_track_diag_25_deg_down_to_left_bank(paint_session * sessi
 
 /** rct2: 0x008A69B0 */
 static void looping_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7153,7 +7153,7 @@ static void looping_rc_track_diag_25_deg_down_to_right_bank(paint_session * sess
 
 /** rct2: 0x008A68E0 */
 static void looping_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7220,7 +7220,7 @@ static void looping_rc_track_diag_left_bank(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A68F0 */
 static void looping_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7287,7 +7287,7 @@ static void looping_rc_track_diag_right_bank(paint_session * session, uint8 ride
 
 /** rct2: 0x008A6C00 */
 static void looping_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7318,7 +7318,7 @@ static void looping_rc_track_block_brakes(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008A6BC0 */
 static void looping_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7392,7 +7392,7 @@ static void looping_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session
 /** rct2: 0x008A6BD0 */
 static void looping_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7469,26 +7469,26 @@ static void looping_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session
 /** rct2: 0x008A6BE0 */
 static void looping_rc_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     looping_rc_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                           mapElement);
+                                                           tileElement);
 }
 
 /** rct2: 0x008A6BF0 */
 static void looping_rc_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     looping_rc_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x008A6B80 */
 static void looping_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7641,7 +7641,7 @@ static void looping_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session
 /** rct2: 0x008A6B90 */
 static void looping_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7794,26 +7794,26 @@ static void looping_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session
 /** rct2: 0x008A6BA0 */
 static void looping_rc_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     looping_rc_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                           mapElement);
+                                                           tileElement);
 }
 
 /** rct2: 0x008A6BB0 */
 static void looping_rc_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     looping_rc_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x008A6A80 */
 static void looping_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7855,7 +7855,7 @@ static void looping_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session *
 
 /** rct2: 0x008A6A90 */
 static void looping_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7897,7 +7897,7 @@ static void looping_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session *
 
 /** rct2: 0x008A6AA0 */
 static void looping_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7939,7 +7939,7 @@ static void looping_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session *
 
 /** rct2: 0x008A6AB0 */
 static void looping_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7982,43 +7982,43 @@ static void looping_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session *
 /** rct2: 0x008A6AC0 */
 static void looping_rc_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     looping_rc_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x008A6AD0 */
 static void looping_rc_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     looping_rc_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008A6AE0 */
 static void looping_rc_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     looping_rc_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x008A6AF0 */
 static void looping_rc_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     looping_rc_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008A6B00 */
 static void looping_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8059,7 +8059,7 @@ static void looping_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_ses
 /** rct2: 0x008A6B10 */
 static void looping_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8100,7 +8100,7 @@ static void looping_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_s
 /** rct2: 0x008A6B40 */
 static void looping_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8141,7 +8141,7 @@ static void looping_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_ses
 /** rct2: 0x008A6B50 */
 static void looping_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8182,42 +8182,42 @@ static void looping_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_s
 /** rct2: 0x008A6B60 */
 static void looping_rc_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     looping_rc_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                 mapElement);
+                                                                 tileElement);
 }
 
 /** rct2: 0x008A6B70 */
 static void looping_rc_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     looping_rc_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                               mapElement);
+                                                               tileElement);
 }
 
 /** rct2: 0x008A6B20 */
 static void looping_rc_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     looping_rc_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                 mapElement);
+                                                                 tileElement);
 }
 
 /** rct2: 0x008A6B30 */
 static void looping_rc_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     looping_rc_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                               mapElement);
+                                                               tileElement);
 }
 
 /** rct2: 0x008A69C0 */
 static void looping_rc_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8259,7 +8259,7 @@ static void looping_rc_track_flat_to_left_banked_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008A69D0 */
 static void looping_rc_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8301,7 +8301,7 @@ static void looping_rc_track_flat_to_right_banked_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A69E0 */
 static void looping_rc_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8343,7 +8343,7 @@ static void looping_rc_track_left_banked_25_deg_up_to_flat(paint_session * sessi
 
 /** rct2: 0x008A69F0 */
 static void looping_rc_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8385,38 +8385,38 @@ static void looping_rc_track_right_banked_25_deg_up_to_flat(paint_session * sess
 
 /** rct2: 0x008A6A00 */
 static void looping_rc_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6A10 */
 static void looping_rc_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6A20 */
 static void looping_rc_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A6A30 */
 static void looping_rc_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    looping_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    looping_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void looping_rc_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
     if (!is_csg_loaded())
     {
-        looping_rc_track_brakes(session, rideIndex, trackSequence, direction, height, mapElement);
+        looping_rc_track_brakes(session, rideIndex, trackSequence, direction, height, tileElement);
         return;
     }
 
diff --git a/src/openrct2/ride/coaster/MineRide.cpp b/src/openrct2/ride/coaster/MineRide.cpp
index be3cde8f26..3ca9339f1a 100644
--- a/src/openrct2/ride/coaster/MineRide.cpp
+++ b/src/openrct2/ride/coaster/MineRide.cpp
@@ -28,7 +28,7 @@
 
 /** rct2: 0x008B08D0 */
 static void mine_ride_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -59,7 +59,7 @@ static void mine_ride_track_flat(paint_session * session, uint8 rideIndex, uint8
 }
 
 static void mine_ride_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 19338, SPR_STATION_BASE_A_SW_NE },
@@ -73,7 +73,7 @@ static void mine_ride_track_station(paint_session * session, uint8 rideIndex, ui
     sub_98196C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -81,7 +81,7 @@ static void mine_ride_track_station(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008B08E0 */
 static void mine_ride_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -135,7 +135,7 @@ static void mine_ride_track_25_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008B08F0 */
 static void mine_ride_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -189,7 +189,7 @@ static void mine_ride_track_flat_to_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x008B0900 */
 static void mine_ride_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -243,28 +243,28 @@ static void mine_ride_track_25_deg_up_to_flat(paint_session * session, uint8 rid
 
 /** rct2: 0x008B0910 */
 static void mine_ride_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    mine_ride_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0920 */
 static void mine_ride_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    mine_ride_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0930 */
 static void mine_ride_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    mine_ride_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0940 */
 static void mine_ride_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -428,15 +428,15 @@ static void mine_ride_track_left_quarter_turn_5(paint_session * session, uint8 r
 
 /** rct2: 0x008B0950 */
 static void mine_ride_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mine_ride_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_ride_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0960 */
 static void mine_ride_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -487,7 +487,7 @@ static void mine_ride_track_flat_to_left_bank(paint_session * session, uint8 rid
 
 /** rct2: 0x008B0970 */
 static void mine_ride_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -538,7 +538,7 @@ static void mine_ride_track_flat_to_right_bank(paint_session * session, uint8 ri
 
 /** rct2: 0x008B0980 */
 static void mine_ride_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -589,7 +589,7 @@ static void mine_ride_track_left_bank_to_flat(paint_session * session, uint8 rid
 
 /** rct2: 0x008B0990 */
 static void mine_ride_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -640,7 +640,7 @@ static void mine_ride_track_right_bank_to_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x008B09A0 */
 static void mine_ride_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -808,15 +808,15 @@ static void mine_ride_track_banked_left_quarter_turn_5(paint_session * session,
 
 /** rct2: 0x008B09B0 */
 static void mine_ride_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mine_ride_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_ride_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B09C0 */
 static void mine_ride_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -874,7 +874,7 @@ static void mine_ride_track_left_bank_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x008B09D0 */
 static void mine_ride_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -932,7 +932,7 @@ static void mine_ride_track_right_bank_to_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x008B09E0 */
 static void mine_ride_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -990,7 +990,7 @@ static void mine_ride_track_25_deg_up_to_left_bank(paint_session * session, uint
 
 /** rct2: 0x008B09F0 */
 static void mine_ride_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1048,35 +1048,35 @@ static void mine_ride_track_25_deg_up_to_right_bank(paint_session * session, uin
 
 /** rct2: 0x008B0A00 */
 static void mine_ride_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_ride_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0A10 */
 static void mine_ride_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_ride_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0A20 */
 static void mine_ride_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_ride_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0A30 */
 static void mine_ride_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_ride_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0A40 */
 static void mine_ride_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1123,14 +1123,14 @@ static void mine_ride_track_left_bank(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008B0A50 */
 static void mine_ride_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    mine_ride_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0A60 */
 static void mine_ride_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1266,7 +1266,7 @@ static void mine_ride_track_s_bend_left(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008B0A70 */
 static void mine_ride_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1402,7 +1402,7 @@ static void mine_ride_track_s_bend_right(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008B0AB0 */
 static void mine_ride_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1511,15 +1511,15 @@ static void mine_ride_track_left_quarter_turn_3(paint_session * session, uint8 r
 
 /** rct2: 0x008B0AC0 */
 static void mine_ride_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mine_ride_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_ride_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0AD0 */
 static void mine_ride_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1632,15 +1632,15 @@ static void mine_ride_track_left_quarter_turn_3_bank(paint_session * session, ui
 
 /** rct2: 0x008B0AE0 */
 static void mine_ride_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mine_ride_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_ride_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0AF0 */
 static void mine_ride_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1861,7 +1861,7 @@ static void mine_ride_track_left_half_banked_helix_up_small(paint_session * sess
 
 /** rct2: 0x008B0B00 */
 static void mine_ride_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2082,7 +2082,7 @@ static void mine_ride_track_right_half_banked_helix_up_small(paint_session * ses
 
 /** rct2: 0x008B0B10 */
 static void mine_ride_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2091,12 +2091,12 @@ static void mine_ride_track_left_half_banked_helix_down_small(paint_session * se
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     mine_ride_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008B0B20 */
 static void mine_ride_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2104,12 +2104,12 @@ static void mine_ride_track_right_half_banked_helix_down_small(paint_session * s
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mine_ride_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_ride_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0B30 */
 static void mine_ride_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2440,7 +2440,7 @@ static void mine_ride_track_left_half_banked_helix_up_large(paint_session * sess
 
 /** rct2: 0x008B0B40 */
 static void mine_ride_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2771,7 +2771,7 @@ static void mine_ride_track_right_half_banked_helix_up_large(paint_session * ses
 
 /** rct2: 0x008B0B50 */
 static void mine_ride_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -2780,12 +2780,12 @@ static void mine_ride_track_left_half_banked_helix_down_large(paint_session * se
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     mine_ride_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008B0B60 */
 static void mine_ride_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -2793,12 +2793,12 @@ static void mine_ride_track_right_half_banked_helix_down_large(paint_session * s
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mine_ride_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_ride_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0B70 */
 static void mine_ride_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -2831,7 +2831,7 @@ static void mine_ride_track_on_ride_photo(paint_session * session, uint8 rideInd
                            height + 3);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -2839,7 +2839,7 @@ static void mine_ride_track_on_ride_photo(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008B0B90 */
 static void mine_ride_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2970,7 +2970,7 @@ static void mine_ride_track_left_eighth_to_diag(paint_session * session, uint8 r
 
 /** rct2: 0x008B0BA0 */
 static void mine_ride_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3101,23 +3101,23 @@ static void mine_ride_track_right_eighth_to_diag(paint_session * session, uint8
 
 /** rct2: 0x008B0BB0 */
 static void mine_ride_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mine_ride_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0BC0 */
 static void mine_ride_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mine_ride_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    mine_ride_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0BD0 */
 static void mine_ride_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3248,7 +3248,7 @@ static void mine_ride_track_left_eighth_bank_to_diag(paint_session * session, ui
 
 /** rct2: 0x008B0BE0 */
 static void mine_ride_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3379,23 +3379,23 @@ static void mine_ride_track_right_eighth_bank_to_diag(paint_session * session, u
 
 /** rct2: 0x008B0BF0 */
 static void mine_ride_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mine_ride_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_ride_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0C00 */
 static void mine_ride_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mine_ride_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    mine_ride_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008B0B80 */
 static void mine_ride_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3464,7 +3464,7 @@ static void mine_ride_track_diag_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008B0C30 */
 static void mine_ride_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3533,7 +3533,7 @@ static void mine_ride_track_diag_25_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008B0C10 */
 static void mine_ride_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3602,7 +3602,7 @@ static void mine_ride_track_diag_flat_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x008B0C20 */
 static void mine_ride_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3671,7 +3671,7 @@ static void mine_ride_track_diag_25_deg_up_to_flat(paint_session * session, uint
 
 /** rct2: 0x008B0C60 */
 static void mine_ride_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3740,7 +3740,7 @@ static void mine_ride_track_diag_25_deg_down(paint_session * session, uint8 ride
 
 /** rct2: 0x008B0C40 */
 static void mine_ride_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3807,7 +3807,7 @@ static void mine_ride_track_diag_flat_to_25_deg_down(paint_session * session, ui
 
 /** rct2: 0x008B0C50 */
 static void mine_ride_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3876,7 +3876,7 @@ static void mine_ride_track_diag_25_deg_down_to_flat(paint_session * session, ui
 
 /** rct2: 0x008B0C90 */
 static void mine_ride_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3947,7 +3947,7 @@ static void mine_ride_track_diag_flat_to_left_bank(paint_session * session, uint
 
 /** rct2: 0x008B0CA0 */
 static void mine_ride_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4018,7 +4018,7 @@ static void mine_ride_track_diag_flat_to_right_bank(paint_session * session, uin
 
 /** rct2: 0x008B0CB0 */
 static void mine_ride_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4089,7 +4089,7 @@ static void mine_ride_track_diag_left_bank_to_flat(paint_session * session, uint
 
 /** rct2: 0x008B0CC0 */
 static void mine_ride_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4160,7 +4160,7 @@ static void mine_ride_track_diag_right_bank_to_flat(paint_session * session, uin
 
 /** rct2: 0x008B0CF0 */
 static void mine_ride_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4231,7 +4231,7 @@ static void mine_ride_track_diag_left_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008B0D00 */
 static void mine_ride_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4302,7 +4302,7 @@ static void mine_ride_track_diag_right_bank_to_25_deg_up(paint_session * session
 
 /** rct2: 0x008B0CD0 */
 static void mine_ride_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4373,7 +4373,7 @@ static void mine_ride_track_diag_25_deg_up_to_left_bank(paint_session * session,
 
 /** rct2: 0x008B0CE0 */
 static void mine_ride_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4444,7 +4444,7 @@ static void mine_ride_track_diag_25_deg_up_to_right_bank(paint_session * session
 
 /** rct2: 0x008B0D10 */
 static void mine_ride_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4513,7 +4513,7 @@ static void mine_ride_track_diag_left_bank_to_25_deg_down(paint_session * sessio
 
 /** rct2: 0x008B0D20 */
 static void mine_ride_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4582,7 +4582,7 @@ static void mine_ride_track_diag_right_bank_to_25_deg_down(paint_session * sessi
 
 /** rct2: 0x008B0D30 */
 static void mine_ride_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4653,7 +4653,7 @@ static void mine_ride_track_diag_25_deg_down_to_left_bank(paint_session * sessio
 
 /** rct2: 0x008B0D40 */
 static void mine_ride_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4724,7 +4724,7 @@ static void mine_ride_track_diag_25_deg_down_to_right_bank(paint_session * sessi
 
 /** rct2: 0x008B0C70 */
 static void mine_ride_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4793,7 +4793,7 @@ static void mine_ride_track_diag_left_bank(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008B0C80 */
 static void mine_ride_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
diff --git a/src/openrct2/ride/coaster/MineTrainCoaster.cpp b/src/openrct2/ride/coaster/MineTrainCoaster.cpp
index c876ff307a..a89e4ff311 100644
--- a/src/openrct2/ride/coaster/MineTrainCoaster.cpp
+++ b/src/openrct2/ride/coaster/MineTrainCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x0071BFA4 */
 static void mine_train_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -81,7 +81,7 @@ static void mine_train_rc_track_flat(paint_session * session, uint8 rideIndex, u
 
 /** rct2: 0x0071C154, 0x0071C164, 0x0071C174 */
 static void mine_train_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 20064, 20060, SPR_STATION_BASE_B_SW_NE },
@@ -92,7 +92,7 @@ static void mine_train_rc_track_station(paint_session * session, uint8 rideIndex
 
     sub_98197C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 28, 1,
                        height - 2, 0, 2, height);
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sub_98199C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20, 1,
                            height, 0, 0, height);
@@ -103,7 +103,7 @@ static void mine_train_rc_track_station(paint_session * session, uint8 rideIndex
                            height, 0, 0, height);
     }
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 3);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -111,9 +111,9 @@ static void mine_train_rc_track_station(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x0071BFB4 */
 static void mine_train_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -179,7 +179,7 @@ static void mine_train_rc_track_25_deg_up(paint_session * session, uint8 rideInd
 
 /** rct2: 0x0071BFC4 */
 static void mine_train_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -218,9 +218,9 @@ static void mine_train_rc_track_60_deg_up(paint_session * session, uint8 rideInd
 
 /** rct2: 0x0071BFD4 */
 static void mine_train_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -286,7 +286,7 @@ static void mine_train_rc_track_flat_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x0071BFE4 */
 static void mine_train_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -329,7 +329,7 @@ static void mine_train_rc_track_25_deg_up_to_60_deg_up(paint_session * session,
 
 /** rct2: 0x0071BFF4 */
 static void mine_train_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -372,9 +372,9 @@ static void mine_train_rc_track_60_deg_up_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x0071C004 */
 static void mine_train_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -440,49 +440,49 @@ static void mine_train_rc_track_25_deg_up_to_flat(paint_session * session, uint8
 
 /** rct2: 0x0071C014 */
 static void mine_train_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C024 */
 static void mine_train_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C034 */
 static void mine_train_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C044 */
 static void mine_train_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C054 */
 static void mine_train_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C064 */
 static void mine_train_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C0B4 */
 static void mine_train_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -654,15 +654,15 @@ static void mine_train_rc_track_left_quarter_turn_5(paint_session * session, uin
 
 /** rct2: 0x0071C0C4 */
 static void mine_train_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mine_train_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_train_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C074 */
 static void mine_train_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -698,7 +698,7 @@ static void mine_train_rc_track_flat_to_left_bank(paint_session * session, uint8
 
 /** rct2: 0x0071C084 */
 static void mine_train_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -734,7 +734,7 @@ static void mine_train_rc_track_flat_to_right_bank(paint_session * session, uint
 
 /** rct2: 0x0071C094 */
 static void mine_train_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -770,7 +770,7 @@ static void mine_train_rc_track_left_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x0071C0A4 */
 static void mine_train_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -806,7 +806,7 @@ static void mine_train_rc_track_right_bank_to_flat(paint_session * session, uint
 
 /** rct2: 0x0071C0D4 */
 static void mine_train_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -984,15 +984,15 @@ static void mine_train_rc_track_banked_left_quarter_turn_5(paint_session * sessi
 
 /** rct2: 0x0071C0E4 */
 static void mine_train_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mine_train_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_train_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C204 */
 static void mine_train_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1035,7 +1035,7 @@ static void mine_train_rc_track_left_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x0071C214 */
 static void mine_train_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1078,7 +1078,7 @@ static void mine_train_rc_track_right_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x0071C224 */
 static void mine_train_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1121,7 +1121,7 @@ static void mine_train_rc_track_25_deg_up_to_left_bank(paint_session * session,
 
 /** rct2: 0x0071C234 */
 static void mine_train_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1164,35 +1164,35 @@ static void mine_train_rc_track_25_deg_up_to_right_bank(paint_session * session,
 
 /** rct2: 0x0071C244 */
 static void mine_train_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C254 */
 static void mine_train_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C264 */
 static void mine_train_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C274 */
 static void mine_train_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C304 */
 static void mine_train_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1224,14 +1224,14 @@ static void mine_train_rc_track_left_bank(paint_session * session, uint8 rideInd
 
 /** rct2: 0x0071C314 */
 static void mine_train_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    mine_train_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C0F4 */
 static void mine_train_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1408,7 +1408,7 @@ static void mine_train_rc_track_left_quarter_turn_5_25_deg_up(paint_session * se
 
 /** rct2: 0x0071C104 */
 static void mine_train_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1585,25 +1585,25 @@ static void mine_train_rc_track_right_quarter_turn_5_25_deg_up(paint_session * s
 
 /** rct2: 0x0071C114 */
 static void mine_train_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     mine_train_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x0071C124 */
 static void mine_train_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     mine_train_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x0071C134 */
 static void mine_train_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1735,7 +1735,7 @@ static void mine_train_rc_track_s_bend_left(paint_session * session, uint8 rideI
 
 /** rct2: 0x0071C144 */
 static void mine_train_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1867,7 +1867,7 @@ static void mine_train_rc_track_s_bend_right(paint_session * session, uint8 ride
 
 /** rct2: 0x0071C184 */
 static void mine_train_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1984,15 +1984,15 @@ static void mine_train_rc_track_left_quarter_turn_3(paint_session * session, uin
 
 /** rct2: 0x0071C194 */
 static void mine_train_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mine_train_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_train_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C1A4 */
 static void mine_train_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2114,15 +2114,15 @@ static void mine_train_rc_track_left_quarter_turn_3_bank(paint_session * session
 
 /** rct2: 0x0071C1B4 */
 static void mine_train_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mine_train_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mine_train_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C1C4 */
 static void mine_train_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2213,7 +2213,7 @@ static void mine_train_rc_track_left_quarter_turn_3_25_deg_up(paint_session * se
 
 /** rct2: 0x0071C1D4 */
 static void mine_train_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2304,25 +2304,25 @@ static void mine_train_rc_track_right_quarter_turn_3_25_deg_up(paint_session * s
 
 /** rct2: 0x0071C1E4 */
 static void mine_train_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     mine_train_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x0071C1F4 */
 static void mine_train_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     mine_train_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x0071C284 */
 static void mine_train_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2573,7 +2573,7 @@ static void mine_train_rc_track_left_half_banked_helix_up_small(paint_session *
 
 /** rct2: 0x0071C294 */
 static void mine_train_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2824,7 +2824,7 @@ static void mine_train_rc_track_right_half_banked_helix_up_small(paint_session *
 
 /** rct2: 0x0071C2A4 */
 static void mine_train_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2833,13 +2833,13 @@ static void mine_train_rc_track_left_half_banked_helix_down_small(paint_session
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     mine_train_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x0071C2B4 */
 static void mine_train_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2848,12 +2848,12 @@ static void mine_train_rc_track_right_half_banked_helix_down_small(paint_session
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     mine_train_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x0071C2C4 */
 static void mine_train_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3228,7 +3228,7 @@ static void mine_train_rc_track_left_half_banked_helix_up_large(paint_session *
 
 /** rct2: 0x0071C2D4 */
 static void mine_train_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3595,7 +3595,7 @@ static void mine_train_rc_track_right_half_banked_helix_up_large(paint_session *
 
 /** rct2: 0x0071C2E4 */
 static void mine_train_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3604,13 +3604,13 @@ static void mine_train_rc_track_left_half_banked_helix_down_large(paint_session
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     mine_train_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x0071C2F4 */
 static void mine_train_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3619,12 +3619,12 @@ static void mine_train_rc_track_right_half_banked_helix_down_large(paint_session
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     mine_train_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x0071C324 */
 static void mine_train_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3648,7 +3648,7 @@ static void mine_train_rc_track_brakes(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x0071C334 */
 static void mine_train_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3673,7 +3673,7 @@ static void mine_train_rc_track_on_ride_photo(paint_session * session, uint8 rid
         wooden_a_supports_paint_setup(session, 7, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 2, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 2, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -3681,7 +3681,7 @@ static void mine_train_rc_track_on_ride_photo(paint_session * session, uint8 rid
 
 /** rct2: 0x0071C354 */
 static void mine_train_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3817,7 +3817,7 @@ static void mine_train_rc_track_left_eighth_to_diag(paint_session * session, uin
 
 /** rct2: 0x0071C364 */
 static void mine_train_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3953,23 +3953,23 @@ static void mine_train_rc_track_right_eighth_to_diag(paint_session * session, ui
 
 /** rct2: 0x0071C374 */
 static void mine_train_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mine_train_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C384 */
 static void mine_train_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mine_train_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    mine_train_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C394 */
 static void mine_train_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4105,7 +4105,7 @@ static void mine_train_rc_track_left_eighth_bank_to_diag(paint_session * session
 
 /** rct2: 0x0071C3A4 */
 static void mine_train_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4241,28 +4241,28 @@ static void mine_train_rc_track_right_eighth_bank_to_diag(paint_session * sessio
 
 /** rct2: 0x0071C3B4 */
 static void mine_train_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mine_train_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mine_train_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C3C4 */
 static void mine_train_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mine_train_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    mine_train_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x0071C344 */
 static void mine_train_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4286,7 +4286,7 @@ static void mine_train_rc_track_diag_flat(paint_session * session, uint8 rideInd
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4330,7 +4330,7 @@ static void mine_train_rc_track_diag_flat(paint_session * session, uint8 rideInd
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4374,7 +4374,7 @@ static void mine_train_rc_track_diag_flat(paint_session * session, uint8 rideInd
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4402,12 +4402,12 @@ static void mine_train_rc_track_diag_flat(paint_session * session, uint8 rideInd
 
 /** rct2: 0x0071C414 */
 static void mine_train_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4431,7 +4431,7 @@ static void mine_train_rc_track_diag_25_deg_up(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4475,7 +4475,7 @@ static void mine_train_rc_track_diag_25_deg_up(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4519,7 +4519,7 @@ static void mine_train_rc_track_diag_25_deg_up(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4547,7 +4547,7 @@ static void mine_train_rc_track_diag_25_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x0071C474 */
 static void mine_train_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4620,12 +4620,12 @@ static void mine_train_rc_track_diag_60_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x0071C3F4 */
 static void mine_train_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4649,7 +4649,7 @@ static void mine_train_rc_track_diag_flat_to_25_deg_up(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4693,7 +4693,7 @@ static void mine_train_rc_track_diag_flat_to_25_deg_up(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4737,7 +4737,7 @@ static void mine_train_rc_track_diag_flat_to_25_deg_up(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4765,7 +4765,7 @@ static void mine_train_rc_track_diag_flat_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x0071C454 */
 static void mine_train_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4838,7 +4838,7 @@ static void mine_train_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sess
 
 /** rct2: 0x0071C464 */
 static void mine_train_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4911,12 +4911,12 @@ static void mine_train_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sess
 
 /** rct2: 0x0071C404 */
 static void mine_train_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4940,7 +4940,7 @@ static void mine_train_rc_track_diag_25_deg_up_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4984,7 +4984,7 @@ static void mine_train_rc_track_diag_25_deg_up_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5028,7 +5028,7 @@ static void mine_train_rc_track_diag_25_deg_up_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5056,12 +5056,12 @@ static void mine_train_rc_track_diag_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x0071C444 */
 static void mine_train_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5085,7 +5085,7 @@ static void mine_train_rc_track_diag_25_deg_down(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5129,7 +5129,7 @@ static void mine_train_rc_track_diag_25_deg_down(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5173,7 +5173,7 @@ static void mine_train_rc_track_diag_25_deg_down(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5201,7 +5201,7 @@ static void mine_train_rc_track_diag_25_deg_down(paint_session * session, uint8
 
 /** rct2: 0x0071C4A4 */
 static void mine_train_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5274,12 +5274,12 @@ static void mine_train_rc_track_diag_60_deg_down(paint_session * session, uint8
 
 /** rct2: 0x0071C424 */
 static void mine_train_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5302,7 +5302,7 @@ static void mine_train_rc_track_diag_flat_to_25_deg_down(paint_session * session
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5345,7 +5345,7 @@ static void mine_train_rc_track_diag_flat_to_25_deg_down(paint_session * session
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5388,7 +5388,7 @@ static void mine_train_rc_track_diag_flat_to_25_deg_down(paint_session * session
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5417,7 +5417,7 @@ static void mine_train_rc_track_diag_flat_to_25_deg_down(paint_session * session
 
 /** rct2: 0x0071C484 */
 static void mine_train_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5490,7 +5490,7 @@ static void mine_train_rc_track_diag_25_deg_down_to_60_deg_down(paint_session *
 
 /** rct2: 0x0071C494 */
 static void mine_train_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5563,12 +5563,12 @@ static void mine_train_rc_track_diag_60_deg_down_to_25_deg_down(paint_session *
 
 /** rct2: 0x0071C434 */
 static void mine_train_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5592,7 +5592,7 @@ static void mine_train_rc_track_diag_25_deg_down_to_flat(paint_session * session
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5636,7 +5636,7 @@ static void mine_train_rc_track_diag_25_deg_down_to_flat(paint_session * session
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5680,7 +5680,7 @@ static void mine_train_rc_track_diag_25_deg_down_to_flat(paint_session * session
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5708,7 +5708,7 @@ static void mine_train_rc_track_diag_25_deg_down_to_flat(paint_session * session
 
 /** rct2: 0x0071C4D4 */
 static void mine_train_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5783,7 +5783,7 @@ static void mine_train_rc_track_diag_flat_to_left_bank(paint_session * session,
 
 /** rct2: 0x0071C4B4 */
 static void mine_train_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5858,7 +5858,7 @@ static void mine_train_rc_track_diag_flat_to_right_bank(paint_session * session,
 
 /** rct2: 0x0071C4C4 */
 static void mine_train_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5933,7 +5933,7 @@ static void mine_train_rc_track_diag_left_bank_to_flat(paint_session * session,
 
 /** rct2: 0x0071C4E4 */
 static void mine_train_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6008,7 +6008,7 @@ static void mine_train_rc_track_diag_right_bank_to_flat(paint_session * session,
 
 /** rct2: 0x0071C514 */
 static void mine_train_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6083,7 +6083,7 @@ static void mine_train_rc_track_diag_left_bank_to_25_deg_up(paint_session * sess
 
 /** rct2: 0x0071C524 */
 static void mine_train_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6158,7 +6158,7 @@ static void mine_train_rc_track_diag_right_bank_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x0071C4F4 */
 static void mine_train_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6233,7 +6233,7 @@ static void mine_train_rc_track_diag_25_deg_up_to_left_bank(paint_session * sess
 
 /** rct2: 0x0071C504 */
 static void mine_train_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6308,7 +6308,7 @@ static void mine_train_rc_track_diag_25_deg_up_to_right_bank(paint_session * ses
 
 /** rct2: 0x0071C534 */
 static void mine_train_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6378,7 +6378,7 @@ static void mine_train_rc_track_diag_left_bank_to_25_deg_down(paint_session * se
 
 /** rct2: 0x0071C544 */
 static void mine_train_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6448,7 +6448,7 @@ static void mine_train_rc_track_diag_right_bank_to_25_deg_down(paint_session * s
 
 /** rct2: 0x0071C554 */
 static void mine_train_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6523,7 +6523,7 @@ static void mine_train_rc_track_diag_25_deg_down_to_left_bank(paint_session * se
 
 /** rct2: 0x0071C564 */
 static void mine_train_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6598,7 +6598,7 @@ static void mine_train_rc_track_diag_25_deg_down_to_right_bank(paint_session * s
 
 /** rct2: 0x0071C3D4 */
 static void mine_train_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6675,7 +6675,7 @@ static void mine_train_rc_track_diag_left_bank(paint_session * session, uint8 ri
 
 /** rct2: 0x0071C3E4 */
 static void mine_train_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6752,7 +6752,7 @@ static void mine_train_rc_track_diag_right_bank(paint_session * session, uint8 r
 
 /** rct2: 0x0071C574 */
 static void mine_train_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
diff --git a/src/openrct2/ride/coaster/MiniRollerCoaster.cpp b/src/openrct2/ride/coaster/MiniRollerCoaster.cpp
index b2ba7b4014..d679f6b536 100644
--- a/src/openrct2/ride/coaster/MiniRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/MiniRollerCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008A4ABC */
 static void mini_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                               rct_tile_element * mapElement)
+                               rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -105,7 +105,7 @@ static void mini_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 t
 }
 
 static void mini_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                  rct_tile_element * mapElement)
+                                  rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 18746, 18742, SPR_STATION_BASE_A_SW_NE },
@@ -114,7 +114,7 @@ static void mini_rc_track_station(paint_session * session, uint8 rideIndex, uint
         { 18747, 18743, SPR_STATION_BASE_A_NW_SE },
     };
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 20, 1,
                            height, 0, 6, height + 3);
@@ -127,7 +127,7 @@ static void mini_rc_track_station(paint_session * session, uint8 rideIndex, uint
     sub_98196C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -135,9 +135,9 @@ static void mini_rc_track_station(paint_session * session, uint8 rideIndex, uint
 
 /** rct2: 0x008A4ACC */
 static void mini_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -236,7 +236,7 @@ static void mini_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008A4ADC */
 static void mini_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -290,9 +290,9 @@ static void mini_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008A4AEC */
 static void mini_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -391,7 +391,7 @@ static void mini_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A4AFC */
 static void mini_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -449,7 +449,7 @@ static void mini_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A4B0C */
 static void mini_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -507,9 +507,9 @@ static void mini_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A4B1C */
 static void mini_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -608,49 +608,49 @@ static void mini_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A4B2C */
 static void mini_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4B3C */
 static void mini_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4B4C */
 static void mini_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4B5C */
 static void mini_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4B6C */
 static void mini_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4B7C */
 static void mini_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4B8C */
 static void mini_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -814,15 +814,15 @@ static void mini_rc_track_left_quarter_turn_5(paint_session * session, uint8 rid
 
 /** rct2: 0x008A4B9C */
 static void mini_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mini_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4BAC */
 static void mini_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -873,7 +873,7 @@ static void mini_rc_track_flat_to_left_bank(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A4BBC */
 static void mini_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -924,7 +924,7 @@ static void mini_rc_track_flat_to_right_bank(paint_session * session, uint8 ride
 
 /** rct2: 0x008A4BCC */
 static void mini_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -975,7 +975,7 @@ static void mini_rc_track_left_bank_to_flat(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A4BDC */
 static void mini_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1026,7 +1026,7 @@ static void mini_rc_track_right_bank_to_flat(paint_session * session, uint8 ride
 
 /** rct2: 0x008A4BEC */
 static void mini_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1194,15 +1194,15 @@ static void mini_rc_track_banked_left_quarter_turn_5(paint_session * session, ui
 
 /** rct2: 0x008A4BFC */
 static void mini_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mini_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4C0C */
 static void mini_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1260,7 +1260,7 @@ static void mini_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A4C1C */
 static void mini_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1318,7 +1318,7 @@ static void mini_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A4C2C */
 static void mini_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1376,7 +1376,7 @@ static void mini_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8
 
 /** rct2: 0x008A4C3C */
 static void mini_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1434,35 +1434,35 @@ static void mini_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x008A4C4C */
 static void mini_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4C5C */
 static void mini_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4C6C */
 static void mini_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4C7C */
 static void mini_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4C8C */
 static void mini_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1509,14 +1509,14 @@ static void mini_rc_track_left_bank(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008A4C9C */
 static void mini_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4CAC */
 static void mini_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1675,7 +1675,7 @@ static void mini_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session,
 
 /** rct2: 0x008A4CBC */
 static void mini_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1834,23 +1834,23 @@ static void mini_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session
 
 /** rct2: 0x008A4CCC */
 static void mini_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mini_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    mini_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4CDC */
 static void mini_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mini_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4CEC */
 static void mini_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1986,7 +1986,7 @@ static void mini_rc_track_s_bend_left(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A4CFC */
 static void mini_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2122,7 +2122,7 @@ static void mini_rc_track_s_bend_right(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A4D3C */
 static void mini_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2231,15 +2231,15 @@ static void mini_rc_track_left_quarter_turn_3(paint_session * session, uint8 rid
 
 /** rct2: 0x008A4D4C */
 static void mini_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mini_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4D5C */
 static void mini_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2352,15 +2352,15 @@ static void mini_rc_track_left_quarter_turn_3_bank(paint_session * session, uint
 
 /** rct2: 0x008A4D6C */
 static void mini_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mini_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4D7C */
 static void mini_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2440,7 +2440,7 @@ static void mini_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session,
 
 /** rct2: 0x008A4D8C */
 static void mini_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2520,23 +2520,23 @@ static void mini_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session
 
 /** rct2: 0x008A4D9C */
 static void mini_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mini_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    mini_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4DAC */
 static void mini_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mini_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4DBC */
 static void mini_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2757,7 +2757,7 @@ static void mini_rc_track_left_half_banked_helix_up_small(paint_session * sessio
 
 /** rct2: 0x008A4DCC */
 static void mini_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2978,7 +2978,7 @@ static void mini_rc_track_right_half_banked_helix_up_small(paint_session * sessi
 
 /** rct2: 0x008A4DDC */
 static void mini_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2986,12 +2986,12 @@ static void mini_rc_track_left_half_banked_helix_down_small(paint_session * sess
         direction = (direction - 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mini_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    mini_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4DEC */
 static void mini_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -2999,12 +2999,12 @@ static void mini_rc_track_right_half_banked_helix_down_small(paint_session * ses
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mini_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4DFC */
 static void mini_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3335,7 +3335,7 @@ static void mini_rc_track_left_half_banked_helix_up_large(paint_session * sessio
 
 /** rct2: 0x008A4E0C */
 static void mini_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3666,7 +3666,7 @@ static void mini_rc_track_right_half_banked_helix_up_large(paint_session * sessi
 
 /** rct2: 0x008A4E1C */
 static void mini_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3674,12 +3674,12 @@ static void mini_rc_track_left_half_banked_helix_down_large(paint_session * sess
         direction = (direction - 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mini_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    mini_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4E2C */
 static void mini_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -3687,12 +3687,12 @@ static void mini_rc_track_right_half_banked_helix_down_large(paint_session * ses
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mini_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4E5C */
 static void mini_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3728,7 +3728,7 @@ static void mini_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session,
 
 /** rct2: 0x008A4E3C */
 static void mini_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3764,21 +3764,21 @@ static void mini_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session
 
 /** rct2: 0x008A4E4C */
 static void mini_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    mini_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4E6C */
 static void mini_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4E7C */
 static void mini_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3810,7 +3810,7 @@ static void mini_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8
 
 /** rct2: 0x008A50CC */
 static void mini_rc_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3864,7 +3864,7 @@ static void mini_rc_track_25_deg_up_left_banked(paint_session * session, uint8 r
 
 /** rct2: 0x008A50DC */
 static void mini_rc_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3918,7 +3918,7 @@ static void mini_rc_track_25_deg_up_right_banked(paint_session * session, uint8
 
 /** rct2: 0x008A4E8C */
 static void mini_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -3951,7 +3951,7 @@ static void mini_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex
                            height + 3);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -3959,21 +3959,21 @@ static void mini_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A50EC */
 static void mini_rc_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A50FC */
 static void mini_rc_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4EAC */
 static void mini_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4104,7 +4104,7 @@ static void mini_rc_track_left_eighth_to_diag(paint_session * session, uint8 rid
 
 /** rct2: 0x008A4EBC */
 static void mini_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4235,23 +4235,23 @@ static void mini_rc_track_right_eighth_to_diag(paint_session * session, uint8 ri
 
 /** rct2: 0x008A4ECC */
 static void mini_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mini_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4EDC */
 static void mini_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mini_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    mini_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4EEC */
 static void mini_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4382,7 +4382,7 @@ static void mini_rc_track_left_eighth_bank_to_diag(paint_session * session, uint
 
 /** rct2: 0x008A4EFC */
 static void mini_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4513,28 +4513,28 @@ static void mini_rc_track_right_eighth_bank_to_diag(paint_session * session, uin
 
 /** rct2: 0x008A4F0C */
 static void mini_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mini_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4F1C */
 static void mini_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mini_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    mini_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A4E9C */
 static void mini_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4559,7 +4559,7 @@ static void mini_rc_track_diag_flat(paint_session * session, uint8 rideIndex, ui
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4584,7 +4584,7 @@ static void mini_rc_track_diag_flat(paint_session * session, uint8 rideIndex, ui
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4609,7 +4609,7 @@ static void mini_rc_track_diag_flat(paint_session * session, uint8 rideIndex, ui
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4666,12 +4666,12 @@ static void mini_rc_track_diag_flat(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008A4F4C */
 static void mini_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4696,7 +4696,7 @@ static void mini_rc_track_diag_25_deg_up(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4721,7 +4721,7 @@ static void mini_rc_track_diag_25_deg_up(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4746,7 +4746,7 @@ static void mini_rc_track_diag_25_deg_up(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4803,7 +4803,7 @@ static void mini_rc_track_diag_25_deg_up(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A4FAC */
 static void mini_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4872,12 +4872,12 @@ static void mini_rc_track_diag_60_deg_up(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A4F2C */
 static void mini_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4902,7 +4902,7 @@ static void mini_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4927,7 +4927,7 @@ static void mini_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4952,7 +4952,7 @@ static void mini_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5009,7 +5009,7 @@ static void mini_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A4F8C */
 static void mini_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5078,7 +5078,7 @@ static void mini_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, u
 
 /** rct2: 0x008A4F9C */
 static void mini_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5147,12 +5147,12 @@ static void mini_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A4F3C */
 static void mini_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5177,7 +5177,7 @@ static void mini_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5202,7 +5202,7 @@ static void mini_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5227,7 +5227,7 @@ static void mini_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5284,12 +5284,12 @@ static void mini_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A4F7C */
 static void mini_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5314,7 +5314,7 @@ static void mini_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5339,7 +5339,7 @@ static void mini_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5364,7 +5364,7 @@ static void mini_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5421,7 +5421,7 @@ static void mini_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A4FDC */
 static void mini_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5490,12 +5490,12 @@ static void mini_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A4F5C */
 static void mini_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5519,7 +5519,7 @@ static void mini_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5543,7 +5543,7 @@ static void mini_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5567,7 +5567,7 @@ static void mini_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5625,7 +5625,7 @@ static void mini_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint
 
 /** rct2: 0x008A4FBC */
 static void mini_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5694,7 +5694,7 @@ static void mini_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * sessio
 
 /** rct2: 0x008A4FCC */
 static void mini_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5763,12 +5763,12 @@ static void mini_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * sessio
 
 /** rct2: 0x008A4F6C */
 static void mini_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5793,7 +5793,7 @@ static void mini_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5818,7 +5818,7 @@ static void mini_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5843,7 +5843,7 @@ static void mini_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5900,7 +5900,7 @@ static void mini_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint
 
 /** rct2: 0x008A500C */
 static void mini_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5971,7 +5971,7 @@ static void mini_rc_track_diag_flat_to_left_bank(paint_session * session, uint8
 
 /** rct2: 0x008A501C */
 static void mini_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6042,7 +6042,7 @@ static void mini_rc_track_diag_flat_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x008A502C */
 static void mini_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6113,7 +6113,7 @@ static void mini_rc_track_diag_left_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A503C */
 static void mini_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6184,7 +6184,7 @@ static void mini_rc_track_diag_right_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A506C */
 static void mini_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6255,7 +6255,7 @@ static void mini_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A507C */
 static void mini_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6326,7 +6326,7 @@ static void mini_rc_track_diag_right_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008A504C */
 static void mini_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6397,7 +6397,7 @@ static void mini_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, u
 
 /** rct2: 0x008A505C */
 static void mini_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6468,7 +6468,7 @@ static void mini_rc_track_diag_25_deg_up_to_right_bank(paint_session * session,
 
 /** rct2: 0x008A508C */
 static void mini_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6537,7 +6537,7 @@ static void mini_rc_track_diag_left_bank_to_25_deg_down(paint_session * session,
 
 /** rct2: 0x008A509C */
 static void mini_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6606,7 +6606,7 @@ static void mini_rc_track_diag_right_bank_to_25_deg_down(paint_session * session
 
 /** rct2: 0x008A50AC */
 static void mini_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6677,7 +6677,7 @@ static void mini_rc_track_diag_25_deg_down_to_left_bank(paint_session * session,
 
 /** rct2: 0x008A50BC */
 static void mini_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6748,7 +6748,7 @@ static void mini_rc_track_diag_25_deg_down_to_right_bank(paint_session * session
 
 /** rct2: 0x008A4FEC */
 static void mini_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6817,7 +6817,7 @@ static void mini_rc_track_diag_left_bank(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A4FFC */
 static void mini_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6886,7 +6886,7 @@ static void mini_rc_track_diag_right_bank(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008A530C */
 static void mini_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -6918,7 +6918,7 @@ static void mini_rc_track_block_brakes(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A510C */
 static void mini_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7001,7 +7001,7 @@ static void mini_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * s
 
 /** rct2: 0x008A511C */
 static void mini_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7084,25 +7084,25 @@ static void mini_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session *
 
 /** rct2: 0x008A512C */
 static void mini_rc_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     mini_rc_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008A513C */
 static void mini_rc_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     mini_rc_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008A514C */
 static void mini_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7264,7 +7264,7 @@ static void mini_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * s
 
 /** rct2: 0x008A515C */
 static void mini_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7426,25 +7426,25 @@ static void mini_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session *
 
 /** rct2: 0x008A516C */
 static void mini_rc_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     mini_rc_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008A517C */
 static void mini_rc_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     mini_rc_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008A518C */
 static void mini_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7500,7 +7500,7 @@ static void mini_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A519C */
 static void mini_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7556,7 +7556,7 @@ static void mini_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * se
 
 /** rct2: 0x008A51AC */
 static void mini_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7612,7 +7612,7 @@ static void mini_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A51BC */
 static void mini_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7668,40 +7668,40 @@ static void mini_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * se
 
 /** rct2: 0x008A51CC */
 static void mini_rc_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     mini_rc_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A51DC */
 static void mini_rc_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     mini_rc_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A51EC */
 static void mini_rc_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     mini_rc_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A51FC */
 static void mini_rc_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     mini_rc_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A520C */
 static void mini_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7756,7 +7756,7 @@ static void mini_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_sessio
 /** rct2: 0x008A521C */
 static void mini_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7811,7 +7811,7 @@ static void mini_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_sess
 /** rct2: 0x008A524C */
 static void mini_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7866,7 +7866,7 @@ static void mini_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_sessio
 /** rct2: 0x008A525C */
 static void mini_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -7921,42 +7921,42 @@ static void mini_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_sess
 /** rct2: 0x008A526C */
 static void mini_rc_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     mini_rc_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008A527C */
 static void mini_rc_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     mini_rc_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008A522C */
 static void mini_rc_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     mini_rc_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008A523C */
 static void mini_rc_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     mini_rc_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                            mapElement);
+                                                            tileElement);
 }
 
 /** rct2: 0x008A528C */
 static void mini_rc_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8012,7 +8012,7 @@ static void mini_rc_track_flat_to_left_banked_25_deg_up(paint_session * session,
 
 /** rct2: 0x008A529C */
 static void mini_rc_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8068,7 +8068,7 @@ static void mini_rc_track_flat_to_right_banked_25_deg_up(paint_session * session
 
 /** rct2: 0x008A52AC */
 static void mini_rc_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8124,7 +8124,7 @@ static void mini_rc_track_left_banked_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x008A52BC */
 static void mini_rc_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -8180,34 +8180,34 @@ static void mini_rc_track_right_banked_25_deg_up_to_flat(paint_session * session
 
 /** rct2: 0x008A52CC */
 static void mini_rc_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A52DC */
 static void mini_rc_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A52EC */
 static void mini_rc_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A52FC */
 static void mini_rc_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void mini_rc_track_left_curved_lift_hill(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8286,7 +8286,7 @@ static void mini_rc_track_left_curved_lift_hill(paint_session * session, uint8 r
 }
 
 static void mini_rc_track_right_curved_lift_hill(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8365,7 +8365,7 @@ static void mini_rc_track_right_curved_lift_hill(paint_session * session, uint8
 }
 
 static void mini_rc_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                  rct_tile_element * mapElement)
+                                  rct_tile_element * tileElement)
 {
     // These offsets could be moved to the g2.dat file when that supports offsets.
     sint8 ne_sw_offsetX = 7;
diff --git a/src/openrct2/ride/coaster/MiniSuspendedCoaster.cpp b/src/openrct2/ride/coaster/MiniSuspendedCoaster.cpp
index 709dc3d3e9..dce2ca0351 100644
--- a/src/openrct2/ride/coaster/MiniSuspendedCoaster.cpp
+++ b/src/openrct2/ride/coaster/MiniSuspendedCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008AFE9C */
 static void mini_suspended_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -84,7 +84,7 @@ static void mini_suspended_rc_track_flat(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008AFF4C, 0x008AFF5C, 0x008AFF6C */
 static void mini_suspended_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_STATION_BASE_C_SW_NE, 28433, SPR_STATION_INVERTED_BAR_E_SW_NE },
@@ -100,7 +100,7 @@ static void mini_suspended_rc_track_station(paint_session * session, uint8 rideI
     sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 1,
                        height + 24, 0, 2, height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 3);
-    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement, STATION_VARIANT_1);
+    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement, STATION_VARIANT_1);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -108,9 +108,9 @@ static void mini_suspended_rc_track_station(paint_session * session, uint8 rideI
 
 /** rct2: 0x008AFEAC */
 static void mini_suspended_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -193,9 +193,9 @@ static void mini_suspended_rc_track_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x008AFEBC */
 static void mini_suspended_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -278,9 +278,9 @@ static void mini_suspended_rc_track_flat_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008AFECC */
 static void mini_suspended_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -363,28 +363,28 @@ static void mini_suspended_rc_track_25_deg_up_to_flat(paint_session * session, u
 
 /** rct2: 0x008AFEDC */
 static void mini_suspended_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    mini_suspended_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_suspended_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AFEEC */
 static void mini_suspended_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_suspended_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_suspended_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AFEFC */
 static void mini_suspended_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    mini_suspended_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_suspended_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AFF0C */
 static void mini_suspended_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -548,15 +548,15 @@ static void mini_suspended_rc_track_left_quarter_turn_5(paint_session * session,
 
 /** rct2: 0x008AFF1C */
 static void mini_suspended_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    mini_suspended_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_suspended_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AFF2C */
 static void mini_suspended_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -718,7 +718,7 @@ static void mini_suspended_rc_track_s_bend_left(paint_session * session, uint8 r
 
 /** rct2: 0x008AFF3C */
 static void mini_suspended_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -880,7 +880,7 @@ static void mini_suspended_rc_track_s_bend_right(paint_session * session, uint8
 
 /** rct2: 0x008AFF7C */
 static void mini_suspended_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -997,15 +997,15 @@ static void mini_suspended_rc_track_left_quarter_turn_3(paint_session * session,
 
 /** rct2: 0x008AFF8C */
 static void mini_suspended_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    mini_suspended_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    mini_suspended_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AFFAC */
 static void mini_suspended_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1161,7 +1161,7 @@ static void mini_suspended_rc_track_left_eighth_to_diag(paint_session * session,
 
 /** rct2: 0x008AFFBC */
 static void mini_suspended_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1317,28 +1317,28 @@ static void mini_suspended_rc_track_right_eighth_to_diag(paint_session * session
 
 /** rct2: 0x008AFFCC */
 static void mini_suspended_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mini_suspended_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    mini_suspended_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AFFDC */
 static void mini_suspended_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    mini_suspended_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    mini_suspended_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AFF9C */
 static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1363,7 +1363,7 @@ static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1388,7 +1388,7 @@ static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1413,7 +1413,7 @@ static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1463,12 +1463,12 @@ static void mini_suspended_rc_track_diag_flat(paint_session * session, uint8 rid
 
 /** rct2: 0x008B000C */
 static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1493,7 +1493,7 @@ static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1518,7 +1518,7 @@ static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1543,7 +1543,7 @@ static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1593,12 +1593,12 @@ static void mini_suspended_rc_track_diag_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x008AFFEC */
 static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1623,7 +1623,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1648,7 +1648,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1673,7 +1673,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * sessi
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1723,12 +1723,12 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008AFFFC */
 static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1753,7 +1753,7 @@ static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1778,7 +1778,7 @@ static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1803,7 +1803,7 @@ static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * sessi
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1853,12 +1853,12 @@ static void mini_suspended_rc_track_diag_25_deg_up_to_flat(paint_session * sessi
 
 /** rct2: 0x008B003C */
 static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1883,7 +1883,7 @@ static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1908,7 +1908,7 @@ static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1933,7 +1933,7 @@ static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1983,12 +1983,12 @@ static void mini_suspended_rc_track_diag_25_deg_down(paint_session * session, ui
 
 /** rct2: 0x008B001C */
 static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2012,7 +2012,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * ses
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2036,7 +2036,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * ses
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2060,7 +2060,7 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * ses
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2110,12 +2110,12 @@ static void mini_suspended_rc_track_diag_flat_to_25_deg_down(paint_session * ses
 
 /** rct2: 0x008B002C */
 static void mini_suspended_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2140,7 +2140,7 @@ static void mini_suspended_rc_track_diag_25_deg_down_to_flat(paint_session * ses
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2165,7 +2165,7 @@ static void mini_suspended_rc_track_diag_25_deg_down_to_flat(paint_session * ses
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2190,7 +2190,7 @@ static void mini_suspended_rc_track_diag_25_deg_down_to_flat(paint_session * ses
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
diff --git a/src/openrct2/ride/coaster/MultiDimensionRollerCoaster.cpp b/src/openrct2/ride/coaster/MultiDimensionRollerCoaster.cpp
index f16d2b43a9..2e93cb6998 100644
--- a/src/openrct2/ride/coaster/MultiDimensionRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/MultiDimensionRollerCoaster.cpp
@@ -28,11 +28,11 @@
 
 /** rct2: 0x00792D88 */
 static void multi_dimension_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -109,7 +109,7 @@ static void multi_dimension_rc_track_flat(paint_session * session, uint8 rideInd
 
 /** rct2: 0x00792F98, 0x00792FA8, 0x00792FB8 */
 static void multi_dimension_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 15810, 15812, SPR_STATION_INVERTED_BAR_A_SW_NE },
@@ -120,7 +120,7 @@ static void multi_dimension_rc_track_station(paint_session * session, uint8 ride
 
     LocationXY16 position = session->MapPosition;
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 26, 1,
                            height, 0, 3, height + 3);
@@ -137,23 +137,23 @@ static void multi_dimension_rc_track_station(paint_session * session, uint8 ride
     bool                                 hasFence;
     if (direction == 0 || direction == 2)
     {
-        hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_NW, hasFence, entranceStyle, direction, height);
     }
     else
     {
-        hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_NE, hasFence, entranceStyle, direction, height);
     }
 
     if (direction == 0 || direction == 2)
     {
-        hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_SE, hasFence, entranceStyle, direction, height);
     }
     else
     {
-        hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_SW, hasFence, entranceStyle, direction, height);
     }
 
@@ -164,11 +164,11 @@ static void multi_dimension_rc_track_station(paint_session * session, uint8 ride
 
 /** rct2: 0x00792D98 */
 static void multi_dimension_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -294,9 +294,9 @@ static void multi_dimension_rc_track_25_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x00792DA8 */
 static void multi_dimension_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -370,11 +370,11 @@ static void multi_dimension_rc_track_60_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x00792DB8 */
 static void multi_dimension_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -500,9 +500,9 @@ static void multi_dimension_rc_track_flat_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x00792DC8 */
 static void multi_dimension_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -584,9 +584,9 @@ static void multi_dimension_rc_track_25_deg_up_to_60_deg_up(paint_session * sess
 
 /** rct2: 0x00792DD8 */
 static void multi_dimension_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -692,11 +692,11 @@ static void multi_dimension_rc_track_60_deg_up_to_25_deg_up(paint_session * sess
 
 /** rct2: 0x00792DE8 */
 static void multi_dimension_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -822,51 +822,51 @@ static void multi_dimension_rc_track_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x00792DF8 */
 static void multi_dimension_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792E08 */
 static void multi_dimension_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792E18 */
 static void multi_dimension_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792E28 */
 static void multi_dimension_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792E38 */
 static void multi_dimension_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792E48 */
 static void multi_dimension_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792E58 */
 static void multi_dimension_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -1185,17 +1185,17 @@ static void multi_dimension_rc_track_left_quarter_turn_5(paint_session * session
 
 /** rct2: 0x00792E68 */
 static void multi_dimension_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    multi_dimension_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    multi_dimension_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792E78 */
 static void multi_dimension_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1268,9 +1268,9 @@ static void multi_dimension_rc_track_flat_to_left_bank(paint_session * session,
 
 /** rct2: 0x00792E88 */
 static void multi_dimension_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1343,9 +1343,9 @@ static void multi_dimension_rc_track_flat_to_right_bank(paint_session * session,
 
 /** rct2: 0x00792E98 */
 static void multi_dimension_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1418,9 +1418,9 @@ static void multi_dimension_rc_track_left_bank_to_flat(paint_session * session,
 
 /** rct2: 0x00792EA8 */
 static void multi_dimension_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1493,9 +1493,9 @@ static void multi_dimension_rc_track_right_bank_to_flat(paint_session * session,
 
 /** rct2: 0x00792EB8 */
 static void multi_dimension_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -1818,18 +1818,18 @@ static void multi_dimension_rc_track_banked_left_quarter_turn_5(paint_session *
 
 /** rct2: 0x00792EC8 */
 static void multi_dimension_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     multi_dimension_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x00792ED8 */
 static void multi_dimension_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -1933,9 +1933,9 @@ static void multi_dimension_rc_track_left_bank_to_25_deg_up(paint_session * sess
 
 /** rct2: 0x00792EE8 */
 static void multi_dimension_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2039,9 +2039,9 @@ static void multi_dimension_rc_track_right_bank_to_25_deg_up(paint_session * ses
 
 /** rct2: 0x00792EF8 */
 static void multi_dimension_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2145,9 +2145,9 @@ static void multi_dimension_rc_track_25_deg_up_to_left_bank(paint_session * sess
 
 /** rct2: 0x00792F08 */
 static void multi_dimension_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2251,39 +2251,39 @@ static void multi_dimension_rc_track_25_deg_up_to_right_bank(paint_session * ses
 
 /** rct2: 0x00792F18 */
 static void multi_dimension_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     multi_dimension_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x00792F28 */
 static void multi_dimension_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792F38 */
 static void multi_dimension_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     multi_dimension_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x00792F48 */
 static void multi_dimension_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792F58 */
 static void multi_dimension_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -2352,16 +2352,16 @@ static void multi_dimension_rc_track_left_bank(paint_session * session, uint8 ri
 
 /** rct2: 0x00792F68 */
 static void multi_dimension_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792F78 */
 static void multi_dimension_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -2639,9 +2639,9 @@ static void multi_dimension_rc_track_s_bend_left(paint_session * session, uint8
 
 /** rct2: 0x00792F88 */
 static void multi_dimension_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -2919,9 +2919,9 @@ static void multi_dimension_rc_track_s_bend_right(paint_session * session, uint8
 
 /** rct2: 0x00792FC8 */
 static void multi_dimension_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3126,17 +3126,17 @@ static void multi_dimension_rc_track_left_quarter_turn_3(paint_session * session
 
 /** rct2: 0x00792FD8 */
 static void multi_dimension_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    multi_dimension_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    multi_dimension_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00792FE8 */
 static void multi_dimension_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3345,19 +3345,19 @@ static void multi_dimension_rc_track_left_quarter_turn_3_bank(paint_session * se
 
 /** rct2: 0x00792FF8 */
 static void multi_dimension_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     multi_dimension_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x00793008 */
 static void multi_dimension_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -3754,9 +3754,9 @@ static void multi_dimension_rc_track_left_half_banked_helix_up_small(paint_sessi
 /** rct2: 0x00793018 */
 static void multi_dimension_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4153,7 +4153,7 @@ static void multi_dimension_rc_track_right_half_banked_helix_up_small(paint_sess
 /** rct2: 0x00793028 */
 static void multi_dimension_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -4162,13 +4162,13 @@ static void multi_dimension_rc_track_left_half_banked_helix_down_small(paint_ses
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     multi_dimension_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x00793038 */
 static void multi_dimension_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -4177,15 +4177,15 @@ static void multi_dimension_rc_track_right_half_banked_helix_down_small(paint_se
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     multi_dimension_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x00793048 */
 static void multi_dimension_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -4810,9 +4810,9 @@ static void multi_dimension_rc_track_left_half_banked_helix_up_large(paint_sessi
 /** rct2: 0x00793058 */
 static void multi_dimension_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5437,7 +5437,7 @@ static void multi_dimension_rc_track_right_half_banked_helix_up_large(paint_sess
 /** rct2: 0x00793068 */
 static void multi_dimension_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -5446,13 +5446,13 @@ static void multi_dimension_rc_track_left_half_banked_helix_down_large(paint_ses
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     multi_dimension_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x00793078 */
 static void multi_dimension_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -5461,14 +5461,14 @@ static void multi_dimension_rc_track_right_half_banked_helix_down_large(paint_se
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     multi_dimension_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 /** rct2: 0x00793088 */
 static void multi_dimension_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -5523,9 +5523,9 @@ static void multi_dimension_rc_track_brakes(paint_session * session, uint8 rideI
 
 /** rct2: 0x00793098 */
 static void multi_dimension_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -5566,7 +5566,7 @@ static void multi_dimension_rc_track_on_ride_photo(paint_session * session, uint
                                height + 3);
             break;
         }
-        track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+        track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
         paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -5612,7 +5612,7 @@ static void multi_dimension_rc_track_on_ride_photo(paint_session * session, uint
                                6, height + 24);
             break;
         }
-        track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+        track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
         paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
         paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
         paint_util_set_general_support_height(session, height + 64, 0x20);
@@ -5621,9 +5621,9 @@ static void multi_dimension_rc_track_on_ride_photo(paint_session * session, uint
 
 /** rct2: 0x00793328 */
 static void multi_dimension_rc_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5693,16 +5693,16 @@ static void multi_dimension_rc_track_90_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x00793338 */
 static void multi_dimension_rc_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00793348 */
 static void multi_dimension_rc_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5780,16 +5780,16 @@ static void multi_dimension_rc_track_60_deg_up_to_90_deg_up(paint_session * sess
 
 /** rct2: 0x00793358 */
 static void multi_dimension_rc_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    multi_dimension_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00793368 */
 static void multi_dimension_rc_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -5861,9 +5861,9 @@ static void multi_dimension_rc_track_90_deg_up_to_60_deg_up(paint_session * sess
 
 /** rct2: 0x00793378 */
 static void multi_dimension_rc_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -5939,9 +5939,9 @@ static void multi_dimension_rc_track_60_deg_down_to_90_deg_down(paint_session *
 
 /** rct2: 0x007930B8 */
 static void multi_dimension_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -6207,9 +6207,9 @@ static void multi_dimension_rc_track_left_eighth_to_diag(paint_session * session
 
 /** rct2: 0x007930C8 */
 static void multi_dimension_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -6475,25 +6475,25 @@ static void multi_dimension_rc_track_right_eighth_to_diag(paint_session * sessio
 
 /** rct2: 0x007930D8 */
 static void multi_dimension_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    multi_dimension_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    multi_dimension_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x007930E8 */
 static void multi_dimension_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    multi_dimension_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    multi_dimension_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x007930F8 */
 static void multi_dimension_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -6759,9 +6759,9 @@ static void multi_dimension_rc_track_left_eighth_bank_to_diag(paint_session * se
 
 /** rct2: 0x00793108 */
 static void multi_dimension_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -7028,33 +7028,33 @@ static void multi_dimension_rc_track_right_eighth_bank_to_diag(paint_session * s
 /** rct2: 0x00793118 */
 static void multi_dimension_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     multi_dimension_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x00793128 */
 static void multi_dimension_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     multi_dimension_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x007930A8 */
 static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7079,7 +7079,7 @@ static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7104,7 +7104,7 @@ static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7129,7 +7129,7 @@ static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7188,7 +7188,7 @@ static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 ri
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7213,7 +7213,7 @@ static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7238,7 +7238,7 @@ static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7263,7 +7263,7 @@ static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 ri
             paint_util_set_general_support_height(session, height + 32, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7314,14 +7314,14 @@ static void multi_dimension_rc_track_diag_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x00793158 */
 static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7346,7 +7346,7 @@ static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uin
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7371,7 +7371,7 @@ static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uin
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7396,7 +7396,7 @@ static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uin
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7455,7 +7455,7 @@ static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uin
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7480,7 +7480,7 @@ static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uin
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7505,7 +7505,7 @@ static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uin
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7530,7 +7530,7 @@ static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uin
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7581,9 +7581,9 @@ static void multi_dimension_rc_track_diag_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x007931B8 */
 static void multi_dimension_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -7730,14 +7730,14 @@ static void multi_dimension_rc_track_diag_60_deg_up(paint_session * session, uin
 
 /** rct2: 0x00793138 */
 static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7762,7 +7762,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * sess
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7787,7 +7787,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * sess
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7812,7 +7812,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * sess
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7871,7 +7871,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * sess
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7896,7 +7896,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * sess
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7921,7 +7921,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * sess
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7946,7 +7946,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * sess
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -7997,9 +7997,9 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_up(paint_session * sess
 
 /** rct2: 0x00793198 */
 static void multi_dimension_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8146,9 +8146,9 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_60_deg_up(paint_session *
 
 /** rct2: 0x007931A8 */
 static void multi_dimension_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8295,14 +8295,14 @@ static void multi_dimension_rc_track_diag_60_deg_up_to_25_deg_up(paint_session *
 
 /** rct2: 0x00793148 */
 static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8327,7 +8327,7 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * sess
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8352,7 +8352,7 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * sess
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8377,7 +8377,7 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * sess
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8436,7 +8436,7 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * sess
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8461,7 +8461,7 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * sess
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8486,7 +8486,7 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * sess
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8511,7 +8511,7 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * sess
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8562,14 +8562,14 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_flat(paint_session * sess
 
 /** rct2: 0x00793188 */
 static void multi_dimension_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8594,7 +8594,7 @@ static void multi_dimension_rc_track_diag_25_deg_down(paint_session * session, u
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8619,7 +8619,7 @@ static void multi_dimension_rc_track_diag_25_deg_down(paint_session * session, u
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8644,7 +8644,7 @@ static void multi_dimension_rc_track_diag_25_deg_down(paint_session * session, u
             paint_util_set_general_support_height(session, height + 56, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8777,9 +8777,9 @@ static void multi_dimension_rc_track_diag_25_deg_down(paint_session * session, u
 
 /** rct2: 0x007931E8 */
 static void multi_dimension_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -8926,14 +8926,14 @@ static void multi_dimension_rc_track_diag_60_deg_down(paint_session * session, u
 
 /** rct2: 0x00793168 */
 static void multi_dimension_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8957,7 +8957,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_down(paint_session * se
                 session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -8981,7 +8981,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_down(paint_session * se
                 session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9005,7 +9005,7 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_down(paint_session * se
                 session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9138,9 +9138,9 @@ static void multi_dimension_rc_track_diag_flat_to_25_deg_down(paint_session * se
 /** rct2: 0x007931C8 */
 static void multi_dimension_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -9288,9 +9288,9 @@ static void multi_dimension_rc_track_diag_25_deg_down_to_60_deg_down(paint_sessi
 /** rct2: 0x007931D8 */
 static void multi_dimension_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -9437,14 +9437,14 @@ static void multi_dimension_rc_track_diag_60_deg_down_to_25_deg_down(paint_sessi
 
 /** rct2: 0x00793178 */
 static void multi_dimension_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
         case 0:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9469,7 +9469,7 @@ static void multi_dimension_rc_track_diag_25_deg_down_to_flat(paint_session * se
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 1:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9494,7 +9494,7 @@ static void multi_dimension_rc_track_diag_25_deg_down_to_flat(paint_session * se
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 2:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9519,7 +9519,7 @@ static void multi_dimension_rc_track_diag_25_deg_down_to_flat(paint_session * se
             paint_util_set_general_support_height(session, height + 48, 0x20);
             break;
         case 3:
-            if (track_element_is_lift_hill(mapElement))
+            if (track_element_is_lift_hill(tileElement))
             {
                 switch (direction)
                 {
@@ -9652,9 +9652,9 @@ static void multi_dimension_rc_track_diag_25_deg_down_to_flat(paint_session * se
 
 /** rct2: 0x00793218 */
 static void multi_dimension_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -9804,9 +9804,9 @@ static void multi_dimension_rc_track_diag_flat_to_left_bank(paint_session * sess
 
 /** rct2: 0x00793228 */
 static void multi_dimension_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -9956,9 +9956,9 @@ static void multi_dimension_rc_track_diag_flat_to_right_bank(paint_session * ses
 
 /** rct2: 0x00793238 */
 static void multi_dimension_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -10108,9 +10108,9 @@ static void multi_dimension_rc_track_diag_left_bank_to_flat(paint_session * sess
 
 /** rct2: 0x00793248 */
 static void multi_dimension_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -10260,9 +10260,9 @@ static void multi_dimension_rc_track_diag_right_bank_to_flat(paint_session * ses
 
 /** rct2: 0x00793278 */
 static void multi_dimension_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -10411,9 +10411,9 @@ static void multi_dimension_rc_track_diag_left_bank_to_25_deg_up(paint_session *
 
 /** rct2: 0x00793288 */
 static void multi_dimension_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -10562,9 +10562,9 @@ static void multi_dimension_rc_track_diag_right_bank_to_25_deg_up(paint_session
 
 /** rct2: 0x00793258 */
 static void multi_dimension_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -10713,9 +10713,9 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_left_bank(paint_session *
 
 /** rct2: 0x00793268 */
 static void multi_dimension_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -10865,9 +10865,9 @@ static void multi_dimension_rc_track_diag_25_deg_up_to_right_bank(paint_session
 /** rct2: 0x00793298 */
 static void multi_dimension_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -11010,9 +11010,9 @@ static void multi_dimension_rc_track_diag_left_bank_to_25_deg_down(paint_session
 /** rct2: 0x007932A8 */
 static void multi_dimension_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -11155,9 +11155,9 @@ static void multi_dimension_rc_track_diag_right_bank_to_25_deg_down(paint_sessio
 /** rct2: 0x007932B8 */
 static void multi_dimension_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -11307,9 +11307,9 @@ static void multi_dimension_rc_track_diag_25_deg_down_to_left_bank(paint_session
 /** rct2: 0x007932C8 */
 static void multi_dimension_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -11458,9 +11458,9 @@ static void multi_dimension_rc_track_diag_25_deg_down_to_right_bank(paint_sessio
 
 /** rct2: 0x007931F8 */
 static void multi_dimension_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -11608,9 +11608,9 @@ static void multi_dimension_rc_track_diag_left_bank(paint_session * session, uin
 
 /** rct2: 0x00793208 */
 static void multi_dimension_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -11758,9 +11758,9 @@ static void multi_dimension_rc_track_diag_right_bank(paint_session * session, ui
 
 /** rct2: 0x007932D8 */
 static void multi_dimension_rc_track_left_flyer_twist_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -11968,9 +11968,9 @@ static void multi_dimension_rc_track_left_flyer_twist_up(paint_session * session
 
 /** rct2: 0x007932E8 */
 static void multi_dimension_rc_track_right_flyer_twist_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12178,9 +12178,9 @@ static void multi_dimension_rc_track_right_flyer_twist_up(paint_session * sessio
 
 /** rct2: 0x007932F8 */
 static void multi_dimension_rc_track_left_flyer_twist_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12388,9 +12388,9 @@ static void multi_dimension_rc_track_left_flyer_twist_down(paint_session * sessi
 
 /** rct2: 0x00793308 */
 static void multi_dimension_rc_track_right_flyer_twist_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12600,9 +12600,9 @@ static void multi_dimension_rc_track_right_flyer_twist_down(paint_session * sess
 static void multi_dimension_rc_track_multidim_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session,
                                                                                         uint8 rideIndex, uint8 trackSequence,
                                                                                         uint8 direction, sint32 height,
-                                                                                        rct_tile_element * mapElement)
+                                                                                        rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -12774,9 +12774,9 @@ static void multi_dimension_rc_track_multidim_inverted_flat_to_90_deg_quarter_lo
 
 /** rct2: 0x00793318 */
 static void multi_dimension_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (direction)
         {
@@ -12830,9 +12830,9 @@ static void multi_dimension_rc_track_block_brakes(paint_session * session, uint8
 static void multi_dimension_rc_track_multidim_90_deg_up_to_inverted_flat_quarter_loop(paint_session * session, uint8 rideIndex,
                                                                                       uint8 trackSequence, uint8 direction,
                                                                                       sint32            height,
-                                                                                      rct_tile_element * mapElement)
+                                                                                      rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13001,9 +13001,9 @@ static void multi_dimension_rc_track_multidim_90_deg_up_to_inverted_flat_quarter
 /** rct2: 0x00793398 */
 static void multi_dimension_rc_track_multidim_flat_to_90_deg_down_quarter_loop(paint_session * session, uint8 rideIndex,
                                                                                uint8 trackSequence, uint8 direction,
-                                                                               sint32 height, rct_tile_element * mapElement)
+                                                                               sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
@@ -13175,9 +13175,9 @@ static void multi_dimension_rc_track_multidim_flat_to_90_deg_down_quarter_loop(p
 
 /** rct2: 0x00793388 */
 static void multi_dimension_rc_track_elem_255(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    if (!track_element_is_inverted(mapElement))
+    if (!track_element_is_inverted(tileElement))
     {
         switch (trackSequence)
         {
diff --git a/src/openrct2/ride/coaster/ReverseFreefallCoaster.cpp b/src/openrct2/ride/coaster/ReverseFreefallCoaster.cpp
index 6649e20708..05e1083993 100644
--- a/src/openrct2/ride/coaster/ReverseFreefallCoaster.cpp
+++ b/src/openrct2/ride/coaster/ReverseFreefallCoaster.cpp
@@ -201,7 +201,7 @@ static const uint32 reverse_freefall_rc_track_pieces_vertical_supports[4] = {
 };
 
 static void paint_reverse_freefall_rc_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     if (direction & 1)
     {
@@ -222,7 +222,7 @@ static void paint_reverse_freefall_rc_flat(paint_session * session, uint8 rideIn
 }
 
 static void paint_reverse_freefall_rc_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     Ride *                               ride          = get_ride(rideIndex);
     const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
@@ -261,14 +261,14 @@ static void paint_reverse_freefall_rc_station(paint_session * session, uint8 rid
         paint_util_push_tunnel_right(session, height, TUNNEL_6);
     }
 
-    track_paint_util_draw_station_platform(session, ride, direction, height, 5, mapElement);
+    track_paint_util_draw_station_platform(session, ride, direction, height, 5, tileElement);
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
 }
 
 static void paint_reverse_freefall_rc_slope(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     TESTPAINT_IGNORE_ALL();
 
@@ -360,7 +360,7 @@ static void paint_reverse_freefall_rc_slope(paint_session * session, uint8 rideI
 }
 
 static void paint_reverse_freefall_rc_vertical(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     uint32 supportsImageId, trackImageId;
     switch (trackSequence)
diff --git a/src/openrct2/ride/coaster/ReverserRollerCoaster.cpp b/src/openrct2/ride/coaster/ReverserRollerCoaster.cpp
index 54518cc096..74d4c890ae 100644
--- a/src/openrct2/ride/coaster/ReverserRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/ReverserRollerCoaster.cpp
@@ -48,9 +48,9 @@ void vehicle_visual_reverser(paint_session * session, sint32 x, sint32 imageDire
 
 /** rct2: 0x0086E65C */
 static void reverser_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -92,7 +92,7 @@ static void reverser_rc_track_flat(paint_session * session, uint8 rideIndex, uin
 }
 
 static void reverser_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 21506, SPR_STATION_BASE_A_SW_NE },
@@ -106,7 +106,7 @@ static void reverser_rc_track_station(paint_session * session, uint8 rideIndex,
     sub_98199C_rotated(session, direction, imageIds[direction][0] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 27, 2,
                        height, 0, 2, height);
     wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
-    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -114,9 +114,9 @@ static void reverser_rc_track_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x0086E66C */
 static void reverser_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -182,9 +182,9 @@ static void reverser_rc_track_25_deg_up(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x0086E67C */
 static void reverser_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -250,9 +250,9 @@ static void reverser_rc_track_flat_to_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x0086E68C */
 static void reverser_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -318,28 +318,28 @@ static void reverser_rc_track_25_deg_up_to_flat(paint_session * session, uint8 r
 
 /** rct2: 0x0086E69C */
 static void reverser_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    reverser_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    reverser_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0086E6AC */
 static void reverser_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    reverser_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    reverser_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0086E6BC */
 static void reverser_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    reverser_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    reverser_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0086E6CC */
 static void reverser_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -496,15 +496,15 @@ static void reverser_rc_track_left_quarter_turn_5(paint_session * session, uint8
 
 /** rct2: 0x0086E6DC */
 static void reverser_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    reverser_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    reverser_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x0086E6EC */
 static void reverser_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -640,7 +640,7 @@ static void reverser_rc_track_s_bend_left(paint_session * session, uint8 rideInd
 
 /** rct2: 0x0086E6FC */
 static void reverser_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -776,7 +776,7 @@ static void reverser_rc_track_s_bend_right(paint_session * session, uint8 rideIn
 
 /** rct2: 0x0086E73C */
 static void reverser_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -879,15 +879,15 @@ static void reverser_rc_track_left_quarter_turn_3(paint_session * session, uint8
 
 /** rct2: 0x0086E74C */
 static void reverser_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    reverser_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    reverser_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x0086E75C */
 static void reverser_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -911,7 +911,7 @@ static void reverser_rc_track_brakes(paint_session * session, uint8 rideIndex, u
 
 /** rct2: 0x0086E76C */
 static void reverser_rc_track_left_reverser(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1095,7 +1095,7 @@ static void reverser_rc_track_left_reverser(paint_session * session, uint8 rideI
 
 /** rct2: 0x0086E77C */
 static void reverser_rc_track_right_reverser(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
diff --git a/src/openrct2/ride/coaster/SideFrictionRollerCoaster.cpp b/src/openrct2/ride/coaster/SideFrictionRollerCoaster.cpp
index d001ff70ce..7f390c1a0a 100644
--- a/src/openrct2/ride/coaster/SideFrictionRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/SideFrictionRollerCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x0077839C */
 static void side_friction_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -93,7 +93,7 @@ static void side_friction_rc_track_flat(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x007784AC, 0x007784BC, 0x007784CC */
 static void side_friction_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4] = {
         21610,
@@ -105,7 +105,7 @@ static void side_friction_rc_track_station(paint_session * session, uint8 rideIn
     sub_98197C_rotated(session, direction, imageIds[direction] | session->TrackColours[SCHEME_TRACK], 0, 0, 32, 27, 2, height,
                        0, 2, height);
     wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
-    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -113,9 +113,9 @@ static void side_friction_rc_track_station(paint_session * session, uint8 rideIn
 
 /** rct2: 0x007783AC */
 static void side_friction_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -197,9 +197,9 @@ static void side_friction_rc_track_25_deg_up(paint_session * session, uint8 ride
 
 /** rct2: 0x007783CC */
 static void side_friction_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -281,9 +281,9 @@ static void side_friction_rc_track_flat_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x007783FC */
 static void side_friction_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -365,28 +365,28 @@ static void side_friction_rc_track_25_deg_up_to_flat(paint_session * session, ui
 
 /** rct2: 0x0077840C */
 static void side_friction_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    side_friction_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    side_friction_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0077842C */
 static void side_friction_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    side_friction_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    side_friction_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0077845C */
 static void side_friction_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    side_friction_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    side_friction_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0077846C */
 static void side_friction_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -583,15 +583,15 @@ static void side_friction_rc_track_left_quarter_turn_5(paint_session * session,
 
 /** rct2: 0x0077847C */
 static void side_friction_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    side_friction_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    side_friction_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x0077848C */
 static void side_friction_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -759,7 +759,7 @@ static void side_friction_rc_track_s_bend_left(paint_session * session, uint8 ri
 
 /** rct2: 0x0077849C */
 static void side_friction_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -927,7 +927,7 @@ static void side_friction_rc_track_s_bend_right(paint_session * session, uint8 r
 
 /** rct2: 0x007784DC */
 static void side_friction_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1054,15 +1054,15 @@ static void side_friction_rc_track_left_quarter_turn_3(paint_session * session,
 
 /** rct2: 0x007784EC */
 static void side_friction_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    side_friction_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    side_friction_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x007784FC */
 static void side_friction_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1090,7 +1090,7 @@ static void side_friction_rc_track_brakes(paint_session * session, uint8 rideInd
 
 /** rct2: 0x007785DC */
 static void side_friction_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1258,7 +1258,7 @@ static void side_friction_rc_track_left_eighth_to_diag(paint_session * session,
 
 /** rct2: 0x007785EC */
 static void side_friction_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1426,28 +1426,28 @@ static void side_friction_rc_track_right_eighth_to_diag(paint_session * session,
 
 /** rct2: 0x007785FC */
 static void side_friction_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    side_friction_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    side_friction_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0077860C */
 static void side_friction_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    side_friction_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    side_friction_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x0077850C */
 static void side_friction_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1471,7 +1471,7 @@ static void side_friction_rc_track_diag_flat(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1519,7 +1519,7 @@ static void side_friction_rc_track_diag_flat(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1567,7 +1567,7 @@ static void side_friction_rc_track_diag_flat(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1595,12 +1595,12 @@ static void side_friction_rc_track_diag_flat(paint_session * session, uint8 ride
 
 /** rct2: 0x0077853C */
 static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1624,7 +1624,7 @@ static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1672,7 +1672,7 @@ static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1720,7 +1720,7 @@ static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1748,12 +1748,12 @@ static void side_friction_rc_track_diag_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x0077851C */
 static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1777,7 +1777,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1825,7 +1825,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1873,7 +1873,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1901,12 +1901,12 @@ static void side_friction_rc_track_diag_flat_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x0077852C */
 static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1930,7 +1930,7 @@ static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * sessio
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1978,7 +1978,7 @@ static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * sessio
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2026,7 +2026,7 @@ static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * sessio
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2054,12 +2054,12 @@ static void side_friction_rc_track_diag_25_deg_up_to_flat(paint_session * sessio
 
 /** rct2: 0x0077859C */
 static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2083,7 +2083,7 @@ static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2131,7 +2131,7 @@ static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2179,7 +2179,7 @@ static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uin
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2207,12 +2207,12 @@ static void side_friction_rc_track_diag_25_deg_down(paint_session * session, uin
 
 /** rct2: 0x0077857C */
 static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2234,7 +2234,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * sess
         }
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2280,7 +2280,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * sess
         }
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2326,7 +2326,7 @@ static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * sess
         }
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2355,12 +2355,12 @@ static void side_friction_rc_track_diag_flat_to_25_deg_down(paint_session * sess
 
 /** rct2: 0x0077858C */
 static void side_friction_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2384,7 +2384,7 @@ static void side_friction_rc_track_diag_25_deg_down_to_flat(paint_session * sess
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2432,7 +2432,7 @@ static void side_friction_rc_track_diag_25_deg_down_to_flat(paint_session * sess
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2480,7 +2480,7 @@ static void side_friction_rc_track_diag_25_deg_down_to_flat(paint_session * sess
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
diff --git a/src/openrct2/ride/coaster/StandUpRollerCoaster.cpp b/src/openrct2/ride/coaster/StandUpRollerCoaster.cpp
index 874a37fa71..9f5ccce5b7 100644
--- a/src/openrct2/ride/coaster/StandUpRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/StandUpRollerCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008A7114 */
 static void stand_up_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -78,7 +78,7 @@ static void stand_up_rc_track_flat(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x008A7384, 0x008A7394, 0x008A73A4 */
 static void stand_up_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 25567, 25571, SPR_STATION_BASE_A_SW_NE },
@@ -87,7 +87,7 @@ static void stand_up_rc_track_station(paint_session * session, uint8 rideIndex,
         { 25568, 25572, SPR_STATION_BASE_A_NW_SE },
     };
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sub_98197C_rotated(session, direction, imageIds[direction][1] | session->TrackColours[SCHEME_TRACK], 0, 6, 32, 20, 1,
                            height, 0, 6, height + 3);
@@ -100,7 +100,7 @@ static void stand_up_rc_track_station(paint_session * session, uint8 rideIndex,
     sub_98196C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 32, 1,
                        height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -108,9 +108,9 @@ static void stand_up_rc_track_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A7124 */
 static void stand_up_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -169,9 +169,9 @@ static void stand_up_rc_track_25_deg_up(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A7134 */
 static void stand_up_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -234,9 +234,9 @@ static void stand_up_rc_track_60_deg_up(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A7144 */
 static void stand_up_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -295,9 +295,9 @@ static void stand_up_rc_track_flat_to_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008A7154 */
 static void stand_up_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -368,9 +368,9 @@ static void stand_up_rc_track_25_deg_up_to_60_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A7164 */
 static void stand_up_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -441,9 +441,9 @@ static void stand_up_rc_track_60_deg_up_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A7174 */
 static void stand_up_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -502,49 +502,49 @@ static void stand_up_rc_track_25_deg_up_to_flat(paint_session * session, uint8 r
 
 /** rct2: 0x008A7184 */
 static void stand_up_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7194 */
 static void stand_up_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A71A4 */
 static void stand_up_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A71B4 */
 static void stand_up_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A71C4 */
 static void stand_up_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A71D4 */
 static void stand_up_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A71E4 */
 static void stand_up_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -678,15 +678,15 @@ static void stand_up_rc_track_left_quarter_turn_5(paint_session * session, uint8
 
 /** rct2: 0x008A71F4 */
 static void stand_up_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    stand_up_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    stand_up_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7204 */
 static void stand_up_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -715,7 +715,7 @@ static void stand_up_rc_track_flat_to_left_bank(paint_session * session, uint8 r
 
 /** rct2: 0x008A7214 */
 static void stand_up_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -744,7 +744,7 @@ static void stand_up_rc_track_flat_to_right_bank(paint_session * session, uint8
 
 /** rct2: 0x008A7224 */
 static void stand_up_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -773,7 +773,7 @@ static void stand_up_rc_track_left_bank_to_flat(paint_session * session, uint8 r
 
 /** rct2: 0x008A7234 */
 static void stand_up_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -802,7 +802,7 @@ static void stand_up_rc_track_right_bank_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A7244 */
 static void stand_up_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -960,15 +960,15 @@ static void stand_up_rc_track_banked_left_quarter_turn_5(paint_session * session
 
 /** rct2: 0x008A7254 */
 static void stand_up_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    stand_up_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    stand_up_rc_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7264 */
 static void stand_up_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1004,7 +1004,7 @@ static void stand_up_rc_track_left_bank_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A7274 */
 static void stand_up_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1040,7 +1040,7 @@ static void stand_up_rc_track_right_bank_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A7284 */
 static void stand_up_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1076,7 +1076,7 @@ static void stand_up_rc_track_25_deg_up_to_left_bank(paint_session * session, ui
 
 /** rct2: 0x008A7294 */
 static void stand_up_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1112,35 +1112,35 @@ static void stand_up_rc_track_25_deg_up_to_right_bank(paint_session * session, u
 
 /** rct2: 0x008A72A4 */
 static void stand_up_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A72B4 */
 static void stand_up_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A72C4 */
 static void stand_up_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A72D4 */
 static void stand_up_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A72E4 */
 static void stand_up_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1169,19 +1169,19 @@ static void stand_up_rc_track_left_bank(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A72F4 */
 static void stand_up_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7304 */
 static void stand_up_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1231,7 +1231,7 @@ static void stand_up_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sess
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1274,7 +1274,7 @@ static void stand_up_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sess
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1318,7 +1318,7 @@ static void stand_up_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sess
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 5:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1361,7 +1361,7 @@ static void stand_up_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sess
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 6:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1417,12 +1417,12 @@ static void stand_up_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A7314 */
 static void stand_up_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1472,7 +1472,7 @@ static void stand_up_rc_track_right_quarter_turn_5_25_deg_up(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1515,7 +1515,7 @@ static void stand_up_rc_track_right_quarter_turn_5_25_deg_up(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1559,7 +1559,7 @@ static void stand_up_rc_track_right_quarter_turn_5_25_deg_up(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 5:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1602,7 +1602,7 @@ static void stand_up_rc_track_right_quarter_turn_5_25_deg_up(paint_session * ses
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 6:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1658,24 +1658,24 @@ static void stand_up_rc_track_right_quarter_turn_5_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A7324 */
 static void stand_up_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     stand_up_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A7334 */
 static void stand_up_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    stand_up_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    stand_up_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7344 */
 static void stand_up_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1787,7 +1787,7 @@ static void stand_up_rc_track_s_bend_left(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008A7354 */
 static void stand_up_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1899,7 +1899,7 @@ static void stand_up_rc_track_s_bend_right(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A7364 */
 static void stand_up_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2109,7 +2109,7 @@ static void stand_up_rc_track_left_vertical_loop(paint_session * session, uint8
 
 /** rct2: 0x008A7374 */
 static void stand_up_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2293,7 +2293,7 @@ static void stand_up_rc_track_right_vertical_loop(paint_session * session, uint8
 
 /** rct2: 0x008A73B4 */
 static void stand_up_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2380,15 +2380,15 @@ static void stand_up_rc_track_left_quarter_turn_3(paint_session * session, uint8
 
 /** rct2: 0x008A73C4 */
 static void stand_up_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    stand_up_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    stand_up_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A73D4 */
 static void stand_up_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2491,20 +2491,20 @@ static void stand_up_rc_track_left_quarter_turn_3_bank(paint_session * session,
 
 /** rct2: 0x008A73E4 */
 static void stand_up_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    stand_up_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    stand_up_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A73F4 */
 static void stand_up_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2557,7 +2557,7 @@ static void stand_up_rc_track_left_quarter_turn_3_25_deg_up(paint_session * sess
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2613,12 +2613,12 @@ static void stand_up_rc_track_left_quarter_turn_3_25_deg_up(paint_session * sess
 
 /** rct2: 0x008A7404 */
 static void stand_up_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2671,7 +2671,7 @@ static void stand_up_rc_track_right_quarter_turn_3_25_deg_up(paint_session * ses
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2741,24 +2741,24 @@ static void stand_up_rc_track_right_quarter_turn_3_25_deg_up(paint_session * ses
 
 /** rct2: 0x008A7414 */
 static void stand_up_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     stand_up_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A7424 */
 static void stand_up_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    stand_up_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    stand_up_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7434 */
 static void stand_up_rc_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2864,14 +2864,14 @@ static void stand_up_rc_track_half_loop_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A7444 */
 static void stand_up_rc_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, mapElement);
+    stand_up_rc_track_half_loop_up(session, rideIndex, 3 - trackSequence, direction, height, tileElement);
 }
 
 /** rct2: 0x008A7454 */
 static void stand_up_rc_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2969,7 +2969,7 @@ static void stand_up_rc_track_left_corkscrew_up(paint_session * session, uint8 r
 
 /** rct2: 0x008A7464 */
 static void stand_up_rc_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3068,21 +3068,21 @@ static void stand_up_rc_track_right_corkscrew_up(paint_session * session, uint8
 
 /** rct2: 0x008A7474 */
 static void stand_up_rc_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, mapElement);
+    stand_up_rc_track_right_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7484 */
 static void stand_up_rc_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    stand_up_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, mapElement);
+    stand_up_rc_track_left_corkscrew_up(session, rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A7734 */
 static void stand_up_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3283,7 +3283,7 @@ static void stand_up_rc_track_left_half_banked_helix_up_small(paint_session * se
 
 /** rct2: 0x008A7744 */
 static void stand_up_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3484,7 +3484,7 @@ static void stand_up_rc_track_right_half_banked_helix_up_small(paint_session * s
 
 /** rct2: 0x008A7754 */
 static void stand_up_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -3493,12 +3493,12 @@ static void stand_up_rc_track_left_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     stand_up_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008A7764 */
 static void stand_up_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -3507,12 +3507,12 @@ static void stand_up_rc_track_right_half_banked_helix_down_small(paint_session *
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     stand_up_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A76F4 */
 static void stand_up_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3823,7 +3823,7 @@ static void stand_up_rc_track_left_half_banked_helix_up_large(paint_session * se
 
 /** rct2: 0x008A7704 */
 static void stand_up_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4134,7 +4134,7 @@ static void stand_up_rc_track_right_half_banked_helix_up_large(paint_session * s
 
 /** rct2: 0x008A7714 */
 static void stand_up_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -4143,12 +4143,12 @@ static void stand_up_rc_track_left_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     stand_up_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008A7724 */
 static void stand_up_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -4157,12 +4157,12 @@ static void stand_up_rc_track_right_half_banked_helix_down_large(paint_session *
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     stand_up_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x008A7494 */
 static void stand_up_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4187,7 +4187,7 @@ static void stand_up_rc_track_brakes(paint_session * session, uint8 rideIndex, u
 
 /** rct2: 0x008A74A4 */
 static void stand_up_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -4220,7 +4220,7 @@ static void stand_up_rc_track_on_ride_photo(paint_session * session, uint8 rideI
                            height + 3);
         break;
     }
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_0);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -4228,7 +4228,7 @@ static void stand_up_rc_track_on_ride_photo(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A74B4 */
 static void stand_up_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4352,7 +4352,7 @@ static void stand_up_rc_track_left_eighth_to_diag(paint_session * session, uint8
 
 /** rct2: 0x008A74C4 */
 static void stand_up_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4476,23 +4476,23 @@ static void stand_up_rc_track_right_eighth_to_diag(paint_session * session, uint
 
 /** rct2: 0x008A74D4 */
 static void stand_up_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    stand_up_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A74E4 */
 static void stand_up_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    stand_up_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    stand_up_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A76A4 */
 static void stand_up_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4616,7 +4616,7 @@ static void stand_up_rc_track_left_eighth_bank_to_diag(paint_session * session,
 
 /** rct2: 0x008A76B4 */
 static void stand_up_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4740,28 +4740,28 @@ static void stand_up_rc_track_right_eighth_bank_to_diag(paint_session * session,
 
 /** rct2: 0x008A76C4 */
 static void stand_up_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    stand_up_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    stand_up_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A76D4 */
 static void stand_up_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    stand_up_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    stand_up_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A74F4 */
 static void stand_up_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4786,7 +4786,7 @@ static void stand_up_rc_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4811,7 +4811,7 @@ static void stand_up_rc_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4836,7 +4836,7 @@ static void stand_up_rc_track_diag_flat(paint_session * session, uint8 rideIndex
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4893,12 +4893,12 @@ static void stand_up_rc_track_diag_flat(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008A7524 */
 static void stand_up_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4923,7 +4923,7 @@ static void stand_up_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4948,7 +4948,7 @@ static void stand_up_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -4973,7 +4973,7 @@ static void stand_up_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5030,12 +5030,12 @@ static void stand_up_rc_track_diag_25_deg_up(paint_session * session, uint8 ride
 
 /** rct2: 0x008A7584 */
 static void stand_up_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5060,7 +5060,7 @@ static void stand_up_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5085,7 +5085,7 @@ static void stand_up_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5110,7 +5110,7 @@ static void stand_up_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5167,12 +5167,12 @@ static void stand_up_rc_track_diag_60_deg_up(paint_session * session, uint8 ride
 
 /** rct2: 0x008A7504 */
 static void stand_up_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5197,7 +5197,7 @@ static void stand_up_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5222,7 +5222,7 @@ static void stand_up_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5247,7 +5247,7 @@ static void stand_up_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5304,12 +5304,12 @@ static void stand_up_rc_track_diag_flat_to_25_deg_up(paint_session * session, ui
 
 /** rct2: 0x008A7564 */
 static void stand_up_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5334,7 +5334,7 @@ static void stand_up_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5359,7 +5359,7 @@ static void stand_up_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5384,7 +5384,7 @@ static void stand_up_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5441,12 +5441,12 @@ static void stand_up_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * sessio
 
 /** rct2: 0x008A7574 */
 static void stand_up_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5471,7 +5471,7 @@ static void stand_up_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5496,7 +5496,7 @@ static void stand_up_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5521,7 +5521,7 @@ static void stand_up_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5578,12 +5578,12 @@ static void stand_up_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008A7514 */
 static void stand_up_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5608,7 +5608,7 @@ static void stand_up_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5633,7 +5633,7 @@ static void stand_up_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5658,7 +5658,7 @@ static void stand_up_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5715,12 +5715,12 @@ static void stand_up_rc_track_diag_25_deg_up_to_flat(paint_session * session, ui
 
 /** rct2: 0x008A7554 */
 static void stand_up_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5745,7 +5745,7 @@ static void stand_up_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5770,7 +5770,7 @@ static void stand_up_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5795,7 +5795,7 @@ static void stand_up_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5852,12 +5852,12 @@ static void stand_up_rc_track_diag_25_deg_down(paint_session * session, uint8 ri
 
 /** rct2: 0x008A75B4 */
 static void stand_up_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5882,7 +5882,7 @@ static void stand_up_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5907,7 +5907,7 @@ static void stand_up_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5932,7 +5932,7 @@ static void stand_up_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
         paint_util_set_general_support_height(session, height + 104, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -5989,12 +5989,12 @@ static void stand_up_rc_track_diag_60_deg_down(paint_session * session, uint8 ri
 
 /** rct2: 0x008A7534 */
 static void stand_up_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6018,7 +6018,7 @@ static void stand_up_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6042,7 +6042,7 @@ static void stand_up_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6066,7 +6066,7 @@ static void stand_up_rc_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6124,12 +6124,12 @@ static void stand_up_rc_track_diag_flat_to_25_deg_down(paint_session * session,
 
 /** rct2: 0x008A7594 */
 static void stand_up_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6154,7 +6154,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6179,7 +6179,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6204,7 +6204,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6261,12 +6261,12 @@ static void stand_up_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * se
 
 /** rct2: 0x008A75A4 */
 static void stand_up_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6291,7 +6291,7 @@ static void stand_up_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6316,7 +6316,7 @@ static void stand_up_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6341,7 +6341,7 @@ static void stand_up_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6398,12 +6398,12 @@ static void stand_up_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * se
 
 /** rct2: 0x008A7544 */
 static void stand_up_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6428,7 +6428,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6453,7 +6453,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6478,7 +6478,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6535,7 +6535,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_flat(paint_session * session,
 
 /** rct2: 0x008A75E4 */
 static void stand_up_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6604,7 +6604,7 @@ static void stand_up_rc_track_diag_flat_to_left_bank(paint_session * session, ui
 
 /** rct2: 0x008A75F4 */
 static void stand_up_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6673,7 +6673,7 @@ static void stand_up_rc_track_diag_flat_to_right_bank(paint_session * session, u
 
 /** rct2: 0x008A7604 */
 static void stand_up_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6742,7 +6742,7 @@ static void stand_up_rc_track_diag_left_bank_to_flat(paint_session * session, ui
 
 /** rct2: 0x008A7614 */
 static void stand_up_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6811,7 +6811,7 @@ static void stand_up_rc_track_diag_right_bank_to_flat(paint_session * session, u
 
 /** rct2: 0x008A7644 */
 static void stand_up_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6880,7 +6880,7 @@ static void stand_up_rc_track_diag_left_bank_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008A7654 */
 static void stand_up_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6949,7 +6949,7 @@ static void stand_up_rc_track_diag_right_bank_to_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008A7624 */
 static void stand_up_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7018,7 +7018,7 @@ static void stand_up_rc_track_diag_25_deg_up_to_left_bank(paint_session * sessio
 
 /** rct2: 0x008A7634 */
 static void stand_up_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7087,7 +7087,7 @@ static void stand_up_rc_track_diag_25_deg_up_to_right_bank(paint_session * sessi
 
 /** rct2: 0x008A7664 */
 static void stand_up_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7154,7 +7154,7 @@ static void stand_up_rc_track_diag_left_bank_to_25_deg_down(paint_session * sess
 
 /** rct2: 0x008A7674 */
 static void stand_up_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7221,7 +7221,7 @@ static void stand_up_rc_track_diag_right_bank_to_25_deg_down(paint_session * ses
 
 /** rct2: 0x008A7684 */
 static void stand_up_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7290,7 +7290,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_left_bank(paint_session * sess
 
 /** rct2: 0x008A7694 */
 static void stand_up_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7359,7 +7359,7 @@ static void stand_up_rc_track_diag_25_deg_down_to_right_bank(paint_session * ses
 
 /** rct2: 0x008A75C4 */
 static void stand_up_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7426,7 +7426,7 @@ static void stand_up_rc_track_diag_left_bank(paint_session * session, uint8 ride
 
 /** rct2: 0x008A75D4 */
 static void stand_up_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7493,7 +7493,7 @@ static void stand_up_rc_track_diag_right_bank(paint_session * session, uint8 rid
 
 /** rct2: 0x008A76E4 */
 static void stand_up_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
diff --git a/src/openrct2/ride/coaster/Steeplechase.cpp b/src/openrct2/ride/coaster/Steeplechase.cpp
index b9b6ca97ce..1a8cea9902 100644
--- a/src/openrct2/ride/coaster/Steeplechase.cpp
+++ b/src/openrct2/ride/coaster/Steeplechase.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008A59A8 */
 static void steeplechase_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -71,7 +71,7 @@ static void steeplechase_track_flat(paint_session * session, uint8 rideIndex, ui
 }
 
 static void steeplechase_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { 28635, SPR_STATION_BASE_B_SW_NE },
@@ -85,7 +85,7 @@ static void steeplechase_track_station(paint_session * session, uint8 rideIndex,
     sub_98199C_rotated(session, direction, imageIds[direction][0] | session->TrackColours[SCHEME_TRACK], 0, 6, 32, 20, 3,
                        height, 0, 0, height);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 3);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -93,9 +93,9 @@ static void steeplechase_track_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A59B8 */
 static void steeplechase_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -158,9 +158,9 @@ static void steeplechase_track_25_deg_up(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A59C8 */
 static void steeplechase_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -223,9 +223,9 @@ static void steeplechase_track_flat_to_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A59D8 */
 static void steeplechase_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -288,28 +288,28 @@ static void steeplechase_track_25_deg_up_to_flat(paint_session * session, uint8
 
 /** rct2: 0x008A59E8 */
 static void steeplechase_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    steeplechase_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    steeplechase_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A59F8 */
 static void steeplechase_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    steeplechase_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    steeplechase_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5A08 */
 static void steeplechase_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    steeplechase_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    steeplechase_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5A18 */
 static void steeplechase_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -455,15 +455,15 @@ static void steeplechase_track_left_quarter_turn_5(paint_session * session, uint
 
 /** rct2: 0x008A5A28 */
 static void steeplechase_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    steeplechase_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    steeplechase_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5A38 */
 static void steeplechase_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -587,7 +587,7 @@ static void steeplechase_track_s_bend_left(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008A5A48 */
 static void steeplechase_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -713,7 +713,7 @@ static void steeplechase_track_s_bend_right(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A5A88 */
 static void steeplechase_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -811,15 +811,15 @@ static void steeplechase_track_left_quarter_turn_3(paint_session * session, uint
 
 /** rct2: 0x008A5A98 */
 static void steeplechase_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    steeplechase_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    steeplechase_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5AA8 */
 static void steeplechase_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -842,7 +842,7 @@ static void steeplechase_track_brakes(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008A5AD8 */
 static void steeplechase_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -973,7 +973,7 @@ static void steeplechase_track_left_eighth_to_diag(paint_session * session, uint
 
 /** rct2: 0x008A5AE8 */
 static void steeplechase_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1104,28 +1104,28 @@ static void steeplechase_track_right_eighth_to_diag(paint_session * session, uin
 
 /** rct2: 0x008A5AF8 */
 static void steeplechase_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    steeplechase_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    steeplechase_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5B08 */
 static void steeplechase_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    steeplechase_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    steeplechase_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5AC8 */
 static void steeplechase_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1150,7 +1150,7 @@ static void steeplechase_track_diag_flat(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1175,7 +1175,7 @@ static void steeplechase_track_diag_flat(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1200,7 +1200,7 @@ static void steeplechase_track_diag_flat(paint_session * session, uint8 rideInde
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1257,12 +1257,12 @@ static void steeplechase_track_diag_flat(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008A5B38 */
 static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1287,7 +1287,7 @@ static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1312,7 +1312,7 @@ static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1337,7 +1337,7 @@ static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rid
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1394,12 +1394,12 @@ static void steeplechase_track_diag_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x008A5B18 */
 static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1424,7 +1424,7 @@ static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1449,7 +1449,7 @@ static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1474,7 +1474,7 @@ static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, u
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1531,12 +1531,12 @@ static void steeplechase_track_diag_flat_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A5B28 */
 static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1561,7 +1561,7 @@ static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1586,7 +1586,7 @@ static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1611,7 +1611,7 @@ static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, u
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1668,12 +1668,12 @@ static void steeplechase_track_diag_25_deg_up_to_flat(paint_session * session, u
 
 /** rct2: 0x008A5B68 */
 static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1698,7 +1698,7 @@ static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1723,7 +1723,7 @@ static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1748,7 +1748,7 @@ static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 r
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1805,12 +1805,12 @@ static void steeplechase_track_diag_25_deg_down(paint_session * session, uint8 r
 
 /** rct2: 0x008A5B48 */
 static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1834,7 +1834,7 @@ static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1858,7 +1858,7 @@ static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1882,7 +1882,7 @@ static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session,
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1940,12 +1940,12 @@ static void steeplechase_track_diag_flat_to_25_deg_down(paint_session * session,
 
 /** rct2: 0x008A5B58 */
 static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1970,7 +1970,7 @@ static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -1995,7 +1995,7 @@ static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2020,7 +2020,7 @@ static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session,
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2077,7 +2077,7 @@ static void steeplechase_track_diag_25_deg_down_to_flat(paint_session * session,
 
 /** rct2: 0x008A5AB8 */
 static void steeplechase_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
diff --git a/src/openrct2/ride/coaster/SuspendedSwingingCoaster.cpp b/src/openrct2/ride/coaster/SuspendedSwingingCoaster.cpp
index f1a78bf173..bdfc70a6ec 100644
--- a/src/openrct2/ride/coaster/SuspendedSwingingCoaster.cpp
+++ b/src/openrct2/ride/coaster/SuspendedSwingingCoaster.cpp
@@ -28,9 +28,9 @@
 
 /** rct2: 0x008A8958 */
 static void suspended_swinging_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -76,7 +76,7 @@ static void suspended_swinging_rc_track_flat(paint_session * session, uint8 ride
 
 /** rct2: 0x008A8AA8, 0x008A8AB8, 0x008A8AC8 */
 static void suspended_swinging_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_STATION_BASE_C_SW_NE, 25963, SPR_STATION_INVERTED_BAR_D_SW_NE },
@@ -92,7 +92,7 @@ static void suspended_swinging_rc_track_station(paint_session * session, uint8 r
     sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 3,
                        height + 29, 0, 6, height + 29);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 0);
-    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
+    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
                                            STATION_VARIANT_TALL);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -101,9 +101,9 @@ static void suspended_swinging_rc_track_station(paint_session * session, uint8 r
 
 /** rct2: 0x008A8968 */
 static void suspended_swinging_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -186,7 +186,7 @@ static void suspended_swinging_rc_track_25_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A8978 */
 static void suspended_swinging_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -222,9 +222,9 @@ static void suspended_swinging_rc_track_60_deg_up(paint_session * session, uint8
 
 /** rct2: 0x008A8988 */
 static void suspended_swinging_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -307,7 +307,7 @@ static void suspended_swinging_rc_track_flat_to_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008A8998 */
 static void suspended_swinging_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -347,9 +347,9 @@ static void suspended_swinging_rc_track_25_deg_up_to_60_deg_up(paint_session * s
 
 /** rct2: 0x008A89A8 */
 static void suspended_swinging_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -440,9 +440,9 @@ static void suspended_swinging_rc_track_60_deg_up_to_25_deg_up(paint_session * s
 
 /** rct2: 0x008A89B8 */
 static void suspended_swinging_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    if (track_element_is_lift_hill(mapElement))
+    if (track_element_is_lift_hill(tileElement))
     {
         switch (direction)
         {
@@ -525,53 +525,53 @@ static void suspended_swinging_rc_track_25_deg_up_to_flat(paint_session * sessio
 
 /** rct2: 0x008A89C8 */
 static void suspended_swinging_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    suspended_swinging_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    suspended_swinging_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A89D8 */
 static void suspended_swinging_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    suspended_swinging_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    suspended_swinging_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A89E8 */
 static void suspended_swinging_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    suspended_swinging_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    suspended_swinging_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A89F8 */
 static void suspended_swinging_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     suspended_swinging_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008A8A08 */
 static void suspended_swinging_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     suspended_swinging_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008A8A18 */
 static void suspended_swinging_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    suspended_swinging_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    suspended_swinging_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A8A28 */
 static void suspended_swinging_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -726,16 +726,16 @@ static void suspended_swinging_rc_track_left_quarter_turn_5(paint_session * sess
 
 /** rct2: 0x008A8A38 */
 static void suspended_swinging_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    suspended_swinging_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    suspended_swinging_rc_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A8A48 */
 static void suspended_swinging_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -877,7 +877,7 @@ static void suspended_swinging_rc_track_left_quarter_turn_5_25_deg_up(paint_sess
 /** rct2: 0x008A8A58 */
 static void suspended_swinging_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1019,26 +1019,26 @@ static void suspended_swinging_rc_track_right_quarter_turn_5_25_deg_up(paint_ses
 /** rct2: 0x008A8A68 */
 static void suspended_swinging_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     suspended_swinging_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                               mapElement);
+                                                               tileElement);
 }
 
 /** rct2: 0x008A8A78 */
 static void suspended_swinging_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     suspended_swinging_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008A8A88 */
 static void suspended_swinging_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1176,7 +1176,7 @@ static void suspended_swinging_rc_track_s_bend_left(paint_session * session, uin
 
 /** rct2: 0x008A8A98 */
 static void suspended_swinging_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1314,7 +1314,7 @@ static void suspended_swinging_rc_track_s_bend_right(paint_session * session, ui
 
 /** rct2: 0x008A8AD8 */
 static void suspended_swinging_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1418,16 +1418,16 @@ static void suspended_swinging_rc_track_left_quarter_turn_3(paint_session * sess
 
 /** rct2: 0x008A8AE8 */
 static void suspended_swinging_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    suspended_swinging_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    suspended_swinging_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A8AF8 */
 static void suspended_swinging_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1504,7 +1504,7 @@ static void suspended_swinging_rc_track_left_quarter_turn_3_25_deg_up(paint_sess
 /** rct2: 0x008A8B08 */
 static void suspended_swinging_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1581,26 +1581,26 @@ static void suspended_swinging_rc_track_right_quarter_turn_3_25_deg_up(paint_ses
 /** rct2: 0x008A8B18 */
 static void suspended_swinging_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     suspended_swinging_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                               mapElement);
+                                                               tileElement);
 }
 
 /** rct2: 0x008A8B28 */
 static void suspended_swinging_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     suspended_swinging_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008A8B38 */
 static void suspended_swinging_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -1630,7 +1630,7 @@ static void suspended_swinging_rc_track_brakes(paint_session * session, uint8 ri
 /** rct2: 0x008A8B48 */
 static void suspended_swinging_rc_track_left_quarter_helix_large_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1791,7 +1791,7 @@ static void suspended_swinging_rc_track_left_quarter_helix_large_up(paint_sessio
 /** rct2: 0x008A8B58 */
 static void suspended_swinging_rc_track_right_quarter_helix_large_up(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1952,7 +1952,7 @@ static void suspended_swinging_rc_track_right_quarter_helix_large_up(paint_sessi
 /** rct2: 0x008A8B68 */
 static void suspended_swinging_rc_track_left_quarter_helix_large_down(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2113,7 +2113,7 @@ static void suspended_swinging_rc_track_left_quarter_helix_large_down(paint_sess
 /** rct2: 0x008A8B78 */
 static void suspended_swinging_rc_track_right_quarter_helix_large_down(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2273,7 +2273,7 @@ static void suspended_swinging_rc_track_right_quarter_helix_large_down(paint_ses
 
 /** rct2: 0x008A8B88 */
 static void suspended_swinging_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2417,7 +2417,7 @@ static void suspended_swinging_rc_track_left_eighth_to_diag(paint_session * sess
 
 /** rct2: 0x008A8B98 */
 static void suspended_swinging_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2561,30 +2561,30 @@ static void suspended_swinging_rc_track_right_eighth_to_diag(paint_session * ses
 
 /** rct2: 0x008A8BA8 */
 static void suspended_swinging_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     suspended_swinging_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008A8BB8 */
 static void suspended_swinging_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    suspended_swinging_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    suspended_swinging_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A8BC8 */
 static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2609,7 +2609,7 @@ static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2634,7 +2634,7 @@ static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2659,7 +2659,7 @@ static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2709,12 +2709,12 @@ static void suspended_swinging_rc_track_diag_flat(paint_session * session, uint8
 
 /** rct2: 0x008A8BF8 */
 static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2739,7 +2739,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2764,7 +2764,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2789,7 +2789,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session,
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2839,7 +2839,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up(paint_session * session,
 
 /** rct2: 0x008A8C58 */
 static void suspended_swinging_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2917,12 +2917,12 @@ static void suspended_swinging_rc_track_diag_60_deg_up(paint_session * session,
 
 /** rct2: 0x008A8BD8 */
 static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2947,7 +2947,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * s
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2972,7 +2972,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * s
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -2997,7 +2997,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * s
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3048,7 +3048,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_up(paint_session * s
 /** rct2: 0x008A8C38 */
 static void suspended_swinging_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3127,7 +3127,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_60_deg_up(paint_sessio
 /** rct2: 0x008A8C48 */
 static void suspended_swinging_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3205,12 +3205,12 @@ static void suspended_swinging_rc_track_diag_60_deg_up_to_25_deg_up(paint_sessio
 
 /** rct2: 0x008A8BE8 */
 static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3235,7 +3235,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3260,7 +3260,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3285,7 +3285,7 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * s
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3335,12 +3335,12 @@ static void suspended_swinging_rc_track_diag_25_deg_up_to_flat(paint_session * s
 
 /** rct2: 0x008A8C28 */
 static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3365,7 +3365,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3390,7 +3390,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3415,7 +3415,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session
         paint_util_set_general_support_height(session, height + 72, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3465,7 +3465,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down(paint_session * session
 
 /** rct2: 0x008A8C88 */
 static void suspended_swinging_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3522,12 +3522,12 @@ static void suspended_swinging_rc_track_diag_60_deg_down(paint_session * session
 
 /** rct2: 0x008A8C08 */
 static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3551,7 +3551,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session *
             session, paint_util_rotate_segments(SEGMENT_BC | SEGMENT_C4 | SEGMENT_CC | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3575,7 +3575,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session *
             session, paint_util_rotate_segments(SEGMENT_B4 | SEGMENT_C4 | SEGMENT_C8 | SEGMENT_CC, direction), 0xFFFF, 0);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3599,7 +3599,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session *
             session, paint_util_rotate_segments(SEGMENT_C0 | SEGMENT_C4 | SEGMENT_D0 | SEGMENT_D4, direction), 0xFFFF, 0);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3650,7 +3650,7 @@ static void suspended_swinging_rc_track_diag_flat_to_25_deg_down(paint_session *
 /** rct2: 0x008A8C68 */
 static void suspended_swinging_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3729,7 +3729,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_60_deg_down(paint_se
 /** rct2: 0x008A8C78 */
 static void suspended_swinging_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3807,12 +3807,12 @@ static void suspended_swinging_rc_track_diag_60_deg_down_to_25_deg_down(paint_se
 
 /** rct2: 0x008A8C18 */
 static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3837,7 +3837,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session *
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3862,7 +3862,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session *
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3887,7 +3887,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session *
         paint_util_set_general_support_height(session, height + 64, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -3937,7 +3937,7 @@ static void suspended_swinging_rc_track_diag_25_deg_down_to_flat(paint_session *
 
 /** rct2: 0x008A8B38 */
 static void suspended_swinging_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
diff --git a/src/openrct2/ride/coaster/TwisterRollerCoaster.cpp b/src/openrct2/ride/coaster/TwisterRollerCoaster.cpp
index 0263bcf486..deaefc72db 100644
--- a/src/openrct2/ride/coaster/TwisterRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/TwisterRollerCoaster.cpp
@@ -29,1440 +29,1440 @@
 
 /** rct2: 0x008AB6A4 */
 static void twister_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                  rct_tile_element * mapElement)
+                                  rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_flat(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB8F4, 0x008AB904, 0x008AB914 */
 static void twister_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_station(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_station(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB6B4 */
 static void twister_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB6C4 */
 static void twister_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB6D4 */
 static void twister_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB6E4 */
 static void twister_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB6F4 */
 static void twister_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB704 */
 static void twister_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB714 */
 static void twister_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB724 */
 static void twister_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB734 */
 static void twister_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB744 */
 static void twister_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB754 */
 static void twister_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB764 */
 static void twister_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB774 */
 static void twister_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_5(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_5(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB784 */
 static void twister_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_5(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_5(session, rideIndex, trackSequence, direction, height, tileElement,
                                                   METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB794 */
 static void twister_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB7A4 */
 static void twister_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                 METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB7B4 */
 static void twister_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_bank_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_bank_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB7C4 */
 static void twister_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_bank_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_bank_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                 METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB7D4 */
 static void twister_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB7E4 */
 static void twister_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_banked_right_quarter_turn_5(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_banked_right_quarter_turn_5(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB7F4 */
 static void twister_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB804 */
 static void twister_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB814 */
 static void twister_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB824 */
 static void twister_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB834 */
 static void twister_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB844 */
 static void twister_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB854 */
 static void twister_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB864 */
 static void twister_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB874 */
 static void twister_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_bank(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_left_bank(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB884 */
 static void twister_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_bank(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_right_bank(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB894 */
 static void twister_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB8A4 */
 static void twister_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB8B4 */
 static void twister_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB8C4 */
 static void twister_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB8D4 */
 static void twister_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_s_bend_left(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_s_bend_left(session, rideIndex, trackSequence, direction, height, tileElement,
                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB8E4 */
 static void twister_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_s_bend_right(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_s_bend_right(session, rideIndex, trackSequence, direction, height, tileElement,
                                           METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA84 */
 static void twister_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_vertical_loop(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_vertical_loop(session, rideIndex, trackSequence, direction, height, tileElement,
                                                 METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA94 */
 static void twister_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_vertical_loop(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_vertical_loop(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB924 */
 static void twister_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_3(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB934 */
 static void twister_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_3(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_3(session, rideIndex, trackSequence, direction, height, tileElement,
                                                   METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB944 */
 static void twister_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB954 */
 static void twister_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_3_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_3_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB964 */
 static void twister_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB974 */
 static void twister_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB984 */
 static void twister_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB994 */
 static void twister_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB9A4 */
 static void twister_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB9B4 */
 static void twister_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB9C4 */
 static void twister_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_half_banked_helix_down_small(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_half_banked_helix_down_small(session, rideIndex, trackSequence, direction, height, tileElement,
                                                                METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB9D4 */
 static void twister_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_half_banked_helix_down_small(session, rideIndex, trackSequence, direction, height,
-                                                                mapElement, METAL_SUPPORTS_TUBES);
+                                                                tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB9E4 */
 static void twister_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AB9F4 */
 static void twister_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA04 */
 static void twister_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_half_banked_helix_down_large(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_half_banked_helix_down_large(session, rideIndex, trackSequence, direction, height, tileElement,
                                                                METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA14 */
 static void twister_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_half_banked_helix_down_large(session, rideIndex, trackSequence, direction, height,
-                                                                mapElement, METAL_SUPPORTS_TUBES);
+                                                                tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA44 */
 static void twister_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA24 */
 static void twister_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA34 */
 static void twister_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA54 */
 static void twister_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA64 */
 static void twister_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_brakes(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_brakes(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE04 */
 static void twister_rc_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_left_banked(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_left_banked(session, rideIndex, trackSequence, direction, height, tileElement,
                                                    METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE14 */
 static void twister_rc_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_right_banked(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_right_banked(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABA74 */
 static void twister_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_on_ride_photo(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_on_ride_photo(session, rideIndex, trackSequence, direction, height, tileElement,
                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE24 */
 static void twister_rc_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_left_banked(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_left_banked(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE34 */
 static void twister_rc_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_right_banked(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_right_banked(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE44 */
 static void twister_rc_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_90_deg_up(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_90_deg_up(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE54 */
 static void twister_rc_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_90_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_90_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE64 */
 static void twister_rc_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE74 */
 static void twister_rc_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_90_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_90_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE84 */
 static void twister_rc_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_90_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_90_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABE94 */
 static void twister_rc_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_down_to_90_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_down_to_90_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABAB4 */
 static void twister_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_eighth_to_diag(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_eighth_to_diag(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABAC4 */
 static void twister_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_eighth_to_diag(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_eighth_to_diag(session, rideIndex, trackSequence, direction, height, tileElement,
                                                   METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABAD4 */
 static void twister_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_eighth_to_orthogonal(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_eighth_to_orthogonal(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABAE4 */
 static void twister_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_eighth_to_orthogonal(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_eighth_to_orthogonal(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABAF4 */
 static void twister_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB04 */
 static void twister_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB14 */
 static void twister_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_eighth_bank_to_orthogonal(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_eighth_bank_to_orthogonal(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB24 */
 static void twister_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_eighth_bank_to_orthogonal(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_eighth_bank_to_orthogonal(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABAA4 */
 static void twister_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_diag_flat(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB54 */
 static void twister_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABBB4 */
 static void twister_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB34 */
 static void twister_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB94 */
 static void twister_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABBA4 */
 static void twister_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB44 */
 static void twister_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB84 */
 static void twister_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABBE4 */
 static void twister_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB64 */
 static void twister_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABBC4 */
 static void twister_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABBD4 */
 static void twister_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABB74 */
 static void twister_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC14 */
 static void twister_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC24 */
 static void twister_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC34 */
 static void twister_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_left_bank_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_left_bank_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC44 */
 static void twister_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_right_bank_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_right_bank_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC74 */
 static void twister_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_left_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_left_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC84 */
 static void twister_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_right_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_right_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC54 */
 static void twister_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC64 */
 static void twister_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC94 */
 static void twister_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_left_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_left_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABCA4 */
 static void twister_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_right_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_right_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABCB4 */
 static void twister_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABCC4 */
 static void twister_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABBF4 */
 static void twister_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABC04 */
 static void twister_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD74 */
 static void twister_rc_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_bank_to_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                        mapElement, METAL_SUPPORTS_TUBES);
+                                                                        tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD84 */
 static void twister_rc_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_bank_to_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                          mapElement, METAL_SUPPORTS_TUBES);
+                                                                          tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD94 */
 static void twister_rc_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_quarter_turn_3_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height,
-                                                                          mapElement, METAL_SUPPORTS_TUBES);
+                                                                          tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABDA4 */
 static void twister_rc_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex,
                                                                             uint8 trackSequence, uint8 direction, sint32 height,
-                                                                            rct_tile_element * mapElement)
+                                                                            rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_quarter_turn_3_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction,
-                                                                            height, mapElement, METAL_SUPPORTS_TUBES);
+                                                                            height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC0E4 */
 static void twister_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_block_brakes(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_block_brakes(session, rideIndex, trackSequence, direction, height, tileElement,
                                           METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABEA4 */
 static void twister_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                  mapElement, METAL_SUPPORTS_TUBES);
+                                                                  tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABEB4 */
 static void twister_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                   mapElement, METAL_SUPPORTS_TUBES);
+                                                                   tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABEC4 */
 static void twister_rc_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                    mapElement, METAL_SUPPORTS_TUBES);
+                                                                    tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABED4 */
 static void twister_rc_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_TUBES);
+                                                                     tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABEE4 */
 static void twister_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                  mapElement, METAL_SUPPORTS_TUBES);
+                                                                  tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABEF4 */
 static void twister_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                   mapElement, METAL_SUPPORTS_TUBES);
+                                                                   tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF04 */
 static void twister_rc_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                    mapElement, METAL_SUPPORTS_TUBES);
+                                                                    tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF14 */
 static void twister_rc_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_TUBES);
+                                                                     tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF24 */
 static void twister_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                mapElement, METAL_SUPPORTS_TUBES);
+                                                                tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF34 */
 static void twister_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                 mapElement, METAL_SUPPORTS_TUBES);
+                                                                 tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF44 */
 static void twister_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                mapElement, METAL_SUPPORTS_TUBES);
+                                                                tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF54 */
 static void twister_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                 mapElement, METAL_SUPPORTS_TUBES);
+                                                                 tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF64 */
 static void twister_rc_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_25_deg_down_to_left_banked_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                    mapElement, METAL_SUPPORTS_TUBES);
+                                                                    tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF74 */
 static void twister_rc_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_25_deg_down_to_right_banked_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_TUBES);
+                                                                     tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF84 */
 static void twister_rc_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_25_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                    mapElement, METAL_SUPPORTS_TUBES);
+                                                                    tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABF94 */
 static void twister_rc_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_25_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_TUBES);
+                                                                     tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABFA4 */
 static void twister_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                       mapElement, METAL_SUPPORTS_TUBES);
+                                                                       tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABFB4 */
 static void twister_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                         mapElement, METAL_SUPPORTS_TUBES);
+                                                                         tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABFE4 */
 static void twister_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, direction, height,
-                                                                       mapElement, METAL_SUPPORTS_TUBES);
+                                                                       tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABFF4 */
 static void twister_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, direction, height,
-                                                                         mapElement, METAL_SUPPORTS_TUBES);
+                                                                         tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC004 */
 static void twister_rc_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                         mapElement, METAL_SUPPORTS_TUBES);
+                                                                         tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC014 */
 static void twister_rc_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                           mapElement, METAL_SUPPORTS_TUBES);
+                                                                           tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABFC4 */
 static void twister_rc_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_25_deg_down_to_left_banked_flat(session, rideIndex, trackSequence, direction, height,
-                                                                         mapElement, METAL_SUPPORTS_TUBES);
+                                                                         tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABFD4 */
 static void twister_rc_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_25_deg_down_to_right_banked_flat(session, rideIndex, trackSequence, direction, height,
-                                                                           mapElement, METAL_SUPPORTS_TUBES);
+                                                                           tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC024 */
 static void twister_rc_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC034 */
 static void twister_rc_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC044 */
 static void twister_rc_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC054 */
 static void twister_rc_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC064 */
 static void twister_rc_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_left_banked_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_left_banked_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC074 */
 static void twister_rc_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_right_banked_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_right_banked_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC084 */
 static void twister_rc_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_banked_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_banked_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC094 */
 static void twister_rc_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_banked_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_banked_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC0A4 */
 static void twister_rc_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC0B4 */
 static void twister_rc_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC0C4 */
 static void twister_rc_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC0D4 */
 static void twister_rc_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_TUBES);
 }
 
 /* The following track elements used to be specific to the Vertical Roller Coaster */
 static void twister_rc_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_brake_for_drop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_brake_for_drop(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_brake_for_drop(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /* The following track elements used to be specific to the Steel Twister */
 /** rct2: 0x008ABCD4 */
 static void twister_rc_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_half_loop_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_half_loop_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                           METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABCE4 */
 static void twister_rc_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_half_loop_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_half_loop_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD34 */
 static void twister_rc_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_corkscrew_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_corkscrew_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD44 */
 static void twister_rc_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_corkscrew_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_corkscrew_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                 METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD54 */
 static void twister_rc_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_corkscrew_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_corkscrew_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD64 */
 static void twister_rc_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_corkscrew_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_corkscrew_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                   METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC0F4 */
 static void twister_rc_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_60_deg_up_long_base(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_up_long_base(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC104 */
 static void twister_rc_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_flat_long_base(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_flat_long_base(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC114 */
 static void twister_rc_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_60_deg_down_long_base(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_down_long_base(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC124 */
 static void twister_rc_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_flat_long_base122(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_flat_long_base122(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABCF4 */
 static void twister_rc_track_left_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_barrel_roll_up_to_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_barrel_roll_up_to_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD04 */
 static void twister_rc_track_right_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_barrel_roll_up_to_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_barrel_roll_up_to_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD14 */
 static void twister_rc_track_left_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_barrel_roll_down_to_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_barrel_roll_down_to_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABD24 */
 static void twister_rc_track_right_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_barrel_roll_down_to_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_barrel_roll_down_to_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABDB4 */
 static void twister_rc_track_powered_lift(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_powered_lift(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_powered_lift(session, rideIndex, trackSequence, direction, height, tileElement,
                                           METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABDC4 */
 static void twister_rc_track_left_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_large_half_loop_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_large_half_loop_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABDD4 */
 static void twister_rc_track_right_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_large_half_loop_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_large_half_loop_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABDE4 */
 static void twister_rc_track_right_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_large_half_loop_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_large_half_loop_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008ABDF4 */
 static void twister_rc_track_left_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_large_half_loop_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_large_half_loop_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC134 */
 static void twister_rc_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_TUBES);
+                                                                     tileElement, METAL_SUPPORTS_TUBES);
 }
 
 /** rct2: 0x008AC144 */
 static void twister_rc_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_inverted_flat_to_90_deg_quarter_loop_down(session, rideIndex, trackSequence, direction, height,
-                                                                       mapElement, METAL_SUPPORTS_TUBES);
+                                                                       tileElement, METAL_SUPPORTS_TUBES);
 }
 
 static void twister_rc_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_booster(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_TUBES);
+    bolliger_mabillard_track_booster(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_TUBES);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_twister_rc(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/coaster/VerticalDropRollerCoaster.cpp b/src/openrct2/ride/coaster/VerticalDropRollerCoaster.cpp
index 97ae7d0128..3c11ffd81d 100644
--- a/src/openrct2/ride/coaster/VerticalDropRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/VerticalDropRollerCoaster.cpp
@@ -21,1456 +21,1456 @@
 
 /** rct2: 0x008AA00C */
 static void vertical_drop_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_flat(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_station(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_station(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA01C */
 static void vertical_drop_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA02C */
 static void vertical_drop_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA03C */
 static void vertical_drop_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA04C */
 static void vertical_drop_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA05C */
 static void vertical_drop_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA06C */
 static void vertical_drop_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA07C */
 static void vertical_drop_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA08C */
 static void vertical_drop_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA09C */
 static void vertical_drop_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA0AC */
 static void vertical_drop_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA0BC */
 static void vertical_drop_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA0CC */
 static void vertical_drop_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA0DC */
 static void vertical_drop_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_5(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_5(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA0EC */
 static void vertical_drop_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_5(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_5(session, rideIndex, trackSequence, direction, height, tileElement,
                                                   METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA0FC */
 static void vertical_drop_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA10C */
 static void vertical_drop_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                 METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA11C */
 static void vertical_drop_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_bank_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_bank_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA12C */
 static void vertical_drop_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_bank_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_bank_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                 METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA13C */
 static void vertical_drop_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_banked_left_quarter_turn_5(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA14C */
 static void vertical_drop_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_banked_right_quarter_turn_5(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_banked_right_quarter_turn_5(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA15C */
 static void vertical_drop_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA16C */
 static void vertical_drop_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA17C */
 static void vertical_drop_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA18C */
 static void vertical_drop_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA19C */
 static void vertical_drop_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA1AC */
 static void vertical_drop_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA1BC */
 static void vertical_drop_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA1CC */
 static void vertical_drop_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA1DC */
 static void vertical_drop_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_bank(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_left_bank(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA1EC */
 static void vertical_drop_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_bank(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_right_bank(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA1FC */
 static void vertical_drop_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA20C */
 static void vertical_drop_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA21C */
 static void vertical_drop_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA22C */
 static void vertical_drop_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA23C */
 static void vertical_drop_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_s_bend_left(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_s_bend_left(session, rideIndex, trackSequence, direction, height, tileElement,
                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA24C */
 static void vertical_drop_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_s_bend_right(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_s_bend_right(session, rideIndex, trackSequence, direction, height, tileElement,
                                           METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA49C */
 static void vertical_drop_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_vertical_loop(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_vertical_loop(session, rideIndex, trackSequence, direction, height, tileElement,
                                                 METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA4AC */
 static void vertical_drop_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_vertical_loop(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_vertical_loop(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA28C */
 static void vertical_drop_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_3(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA29C */
 static void vertical_drop_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_3(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_3(session, rideIndex, trackSequence, direction, height, tileElement,
                                                   METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA2AC */
 static void vertical_drop_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA2BC */
 static void vertical_drop_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_3_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_3_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA2CC */
 static void vertical_drop_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA2DC */
 static void vertical_drop_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA2EC */
 static void vertical_drop_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA2FC */
 static void vertical_drop_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA30C */
 static void vertical_drop_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA31C */
 static void vertical_drop_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA32C */
 static void vertical_drop_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_half_banked_helix_down_small(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_half_banked_helix_down_small(session, rideIndex, trackSequence, direction, height, tileElement,
                                                                METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA33C */
 static void vertical_drop_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_half_banked_helix_down_small(session, rideIndex, trackSequence, direction, height,
-                                                                mapElement, METAL_SUPPORTS_BOXED);
+                                                                tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA34C */
 static void vertical_drop_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA35C */
 static void vertical_drop_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA36C */
 static void vertical_drop_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_half_banked_helix_down_large(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_half_banked_helix_down_large(session, rideIndex, trackSequence, direction, height, tileElement,
                                                                METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA37C */
 static void vertical_drop_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_half_banked_helix_down_large(session, rideIndex, trackSequence, direction, height,
-                                                                mapElement, METAL_SUPPORTS_BOXED);
+                                                                tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA3AC */
 static void vertical_drop_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA38C */
 static void vertical_drop_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA39C */
 static void vertical_drop_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_1_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA3BC */
 static void vertical_drop_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_1_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA40C */
 static void vertical_drop_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_brakes(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_brakes(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA7EC */
 static void vertical_drop_rc_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_left_banked(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_left_banked(session, rideIndex, trackSequence, direction, height, tileElement,
                                                    METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA7FC */
 static void vertical_drop_rc_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_up_right_banked(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_up_right_banked(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA41C */
 static void vertical_drop_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_on_ride_photo(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_on_ride_photo(session, rideIndex, trackSequence, direction, height, tileElement,
                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA80C */
 static void vertical_drop_rc_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_left_banked(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_left_banked(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA81C */
 static void vertical_drop_rc_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_25_deg_down_right_banked(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_25_deg_down_right_banked(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA42C */
 static void vertical_drop_rc_track_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_90_deg_up(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_90_deg_up(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA43C */
 static void vertical_drop_rc_track_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_90_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_90_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA44C */
 static void vertical_drop_rc_track_60_deg_up_to_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_90_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA45C */
 static void vertical_drop_rc_track_90_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_90_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_90_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA46C */
 static void vertical_drop_rc_track_90_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_90_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_90_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA47C */
 static void vertical_drop_rc_track_60_deg_down_to_90_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_down_to_90_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_down_to_90_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA4CC */
 static void vertical_drop_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_eighth_to_diag(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_eighth_to_diag(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA4DC */
 static void vertical_drop_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_eighth_to_diag(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_eighth_to_diag(session, rideIndex, trackSequence, direction, height, tileElement,
                                                   METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA4EC */
 static void vertical_drop_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_eighth_to_orthogonal(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_eighth_to_orthogonal(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA4FC */
 static void vertical_drop_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_eighth_to_orthogonal(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_eighth_to_orthogonal(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA50C */
 static void vertical_drop_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA51C */
 static void vertical_drop_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA52C */
 static void vertical_drop_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_eighth_bank_to_orthogonal(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_eighth_bank_to_orthogonal(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA53C */
 static void vertical_drop_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_eighth_bank_to_orthogonal(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_eighth_bank_to_orthogonal(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA4BC */
 static void vertical_drop_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_diag_flat(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA56C */
 static void vertical_drop_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA5CC */
 static void vertical_drop_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA54C */
 static void vertical_drop_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA5AC */
 static void vertical_drop_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA5BC */
 static void vertical_drop_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA55C */
 static void vertical_drop_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA59C */
 static void vertical_drop_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA5FC */
 static void vertical_drop_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA57C */
 static void vertical_drop_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA5DC */
 static void vertical_drop_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA5EC */
 static void vertical_drop_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA58C */
 static void vertical_drop_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA62C */
 static void vertical_drop_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA63C */
 static void vertical_drop_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA64C */
 static void vertical_drop_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_left_bank_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_left_bank_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA65C */
 static void vertical_drop_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_right_bank_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_right_bank_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA68C */
 static void vertical_drop_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_left_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_left_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA69C */
 static void vertical_drop_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_right_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_right_bank_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA66C */
 static void vertical_drop_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA67C */
 static void vertical_drop_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_up_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_up_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA6AC */
 static void vertical_drop_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_left_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_left_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA6BC */
 static void vertical_drop_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_right_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_right_bank_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA6CC */
 static void vertical_drop_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA6DC */
 static void vertical_drop_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA60C */
 static void vertical_drop_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_left_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_left_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA61C */
 static void vertical_drop_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_right_bank(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_right_bank(session, rideIndex, trackSequence, direction, height, tileElement,
                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA72C */
 static void vertical_drop_rc_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                               uint8 trackSequence, uint8 direction,
-                                                                              sint32 height, rct_tile_element * mapElement)
+                                                                              sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_bank_to_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                        mapElement, METAL_SUPPORTS_BOXED);
+                                                                        tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA73C */
 static void vertical_drop_rc_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                                 uint8 trackSequence, uint8 direction,
-                                                                                sint32 height, rct_tile_element * mapElement)
+                                                                                sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_bank_to_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                          mapElement, METAL_SUPPORTS_BOXED);
+                                                                          tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA74C */
 static void vertical_drop_rc_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex,
                                                                                 uint8 trackSequence, uint8 direction,
-                                                                                sint32 height, rct_tile_element * mapElement)
+                                                                                sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_quarter_turn_3_25_deg_down_to_left_bank(session, rideIndex, trackSequence, direction, height,
-                                                                          mapElement, METAL_SUPPORTS_BOXED);
+                                                                          tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA75C */
 static void vertical_drop_rc_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex,
                                                                                   uint8 trackSequence, uint8 direction,
-                                                                                  sint32 height, rct_tile_element * mapElement)
+                                                                                  sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_quarter_turn_3_25_deg_down_to_right_bank(session, rideIndex, trackSequence, direction,
-                                                                            height, mapElement, METAL_SUPPORTS_BOXED);
+                                                                            height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA9EC */
 static void vertical_drop_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_block_brakes(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_block_brakes(session, rideIndex, trackSequence, direction, height, tileElement,
                                           METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA96C */
 static void vertical_drop_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                  mapElement, METAL_SUPPORTS_BOXED);
+                                                                  tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA97C */
 static void vertical_drop_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                   mapElement, METAL_SUPPORTS_BOXED);
+                                                                   tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA98C */
 static void vertical_drop_rc_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                    mapElement, METAL_SUPPORTS_BOXED);
+                                                                    tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA99C */
 static void vertical_drop_rc_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_BOXED);
+                                                                     tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA8AC */
 static void vertical_drop_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                  mapElement, METAL_SUPPORTS_BOXED);
+                                                                  tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA8BC */
 static void vertical_drop_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                   mapElement, METAL_SUPPORTS_BOXED);
+                                                                   tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA8CC */
 static void vertical_drop_rc_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                    mapElement, METAL_SUPPORTS_BOXED);
+                                                                    tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA8DC */
 static void vertical_drop_rc_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_quarter_turn_5_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_BOXED);
+                                                                     tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA82C */
 static void vertical_drop_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                mapElement, METAL_SUPPORTS_BOXED);
+                                                                tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA83C */
 static void vertical_drop_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                 mapElement, METAL_SUPPORTS_BOXED);
+                                                                 tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA84C */
 static void vertical_drop_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                mapElement, METAL_SUPPORTS_BOXED);
+                                                                tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA85C */
 static void vertical_drop_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                 mapElement, METAL_SUPPORTS_BOXED);
+                                                                 tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA86C */
 static void vertical_drop_rc_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_25_deg_down_to_left_banked_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                    mapElement, METAL_SUPPORTS_BOXED);
+                                                                    tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA87C */
 static void vertical_drop_rc_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_25_deg_down_to_right_banked_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_BOXED);
+                                                                     tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA88C */
 static void vertical_drop_rc_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_25_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                    mapElement, METAL_SUPPORTS_BOXED);
+                                                                    tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA89C */
 static void vertical_drop_rc_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_25_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_BOXED);
+                                                                     tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA8EC */
 static void vertical_drop_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                              uint8 trackSequence, uint8 direction,
-                                                                             sint32 height, rct_tile_element * mapElement)
+                                                                             sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                       mapElement, METAL_SUPPORTS_BOXED);
+                                                                       tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA8FC */
 static void vertical_drop_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                                uint8 trackSequence, uint8 direction,
-                                                                               sint32 height, rct_tile_element * mapElement)
+                                                                               sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, direction, height,
-                                                                         mapElement, METAL_SUPPORTS_BOXED);
+                                                                         tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA92C */
 static void vertical_drop_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                              uint8 trackSequence, uint8 direction,
-                                                                             sint32 height, rct_tile_element * mapElement)
+                                                                             sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, direction, height,
-                                                                       mapElement, METAL_SUPPORTS_BOXED);
+                                                                       tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA93C */
 static void vertical_drop_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                                uint8 trackSequence, uint8 direction,
-                                                                               sint32 height, rct_tile_element * mapElement)
+                                                                               sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, direction, height,
-                                                                         mapElement, METAL_SUPPORTS_BOXED);
+                                                                         tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA94C */
 static void vertical_drop_rc_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                                uint8 trackSequence, uint8 direction,
-                                                                               sint32 height, rct_tile_element * mapElement)
+                                                                               sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_flat_to_left_banked_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                         mapElement, METAL_SUPPORTS_BOXED);
+                                                                         tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA95C */
 static void vertical_drop_rc_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                                  uint8 trackSequence, uint8 direction,
-                                                                                 sint32 height, rct_tile_element * mapElement)
+                                                                                 sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_flat_to_right_banked_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                           mapElement, METAL_SUPPORTS_BOXED);
+                                                                           tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA90C */
 static void vertical_drop_rc_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                                uint8 trackSequence, uint8 direction,
-                                                                               sint32 height, rct_tile_element * mapElement)
+                                                                               sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_left_banked_25_deg_down_to_left_banked_flat(session, rideIndex, trackSequence, direction, height,
-                                                                         mapElement, METAL_SUPPORTS_BOXED);
+                                                                         tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA91C */
 static void vertical_drop_rc_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                                  uint8 trackSequence, uint8 direction,
-                                                                                 sint32 height, rct_tile_element * mapElement)
+                                                                                 sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_right_banked_25_deg_down_to_right_banked_flat(session, rideIndex, trackSequence, direction, height,
-                                                                           mapElement, METAL_SUPPORTS_BOXED);
+                                                                           tileElement, METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA76C */
 static void vertical_drop_rc_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA77C */
 static void vertical_drop_rc_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA78C */
 static void vertical_drop_rc_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA79C */
 static void vertical_drop_rc_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA7AC */
 static void vertical_drop_rc_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_left_banked_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_left_banked_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA7BC */
 static void vertical_drop_rc_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_right_banked_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_right_banked_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA7CC */
 static void vertical_drop_rc_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_banked_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_banked_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA7DC */
 static void vertical_drop_rc_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_banked_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_banked_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA9AC */
 static void vertical_drop_rc_track_left_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA9BC */
 static void vertical_drop_rc_track_right_quarter_turn_1_90_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_1_90_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA9CC */
 static void vertical_drop_rc_track_left_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_quarter_turn_1_90_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                              METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA9DC */
 static void vertical_drop_rc_track_right_quarter_turn_1_90_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_quarter_turn_1_90_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               METAL_SUPPORTS_BOXED);
 }
 
 /* The following elements used to be specific to the vertical_drop RC */
 /** rct2: 0x008AA3CC */
 static void vertical_drop_rc_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA3DC */
 static void vertical_drop_rc_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA3EC */
 static void vertical_drop_rc_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA3FC */
 static void vertical_drop_rc_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA48C */
 static void vertical_drop_rc_track_brake_for_drop(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_brake_for_drop(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_brake_for_drop(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA6EC */
 static void vertical_drop_rc_track_diag_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA6FC */
 static void vertical_drop_rc_track_diag_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                     METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA70C */
 static void vertical_drop_rc_track_diag_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_flat_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_flat_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /** rct2: 0x008AA71C */
 static void vertical_drop_rc_track_diag_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_diag_60_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_diag_60_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 /* The following elements used to be specific to the steel twister RC */
 static void vertical_drop_rc_track_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_half_loop_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_half_loop_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                           METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_half_loop_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_half_loop_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                             METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_left_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_corkscrew_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_corkscrew_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_right_corkscrew_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_corkscrew_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_corkscrew_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                 METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_left_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_corkscrew_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_corkscrew_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_right_corkscrew_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_corkscrew_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_corkscrew_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                   METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_flat_to_60_deg_up_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_60_deg_up_long_base(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_up_long_base(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_60_deg_up_to_flat_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_flat_long_base(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_flat_long_base(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_flat_to_60_deg_down_long_base(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_flat_to_60_deg_down_long_base(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_flat_to_60_deg_down_long_base(session, rideIndex, trackSequence, direction, height, tileElement,
                                                            METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_60_deg_up_to_flat_long_base122(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_60_deg_up_to_flat_long_base122(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_60_deg_up_to_flat_long_base122(session, rideIndex, trackSequence, direction, height, tileElement,
                                                             METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_left_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_barrel_roll_up_to_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_barrel_roll_up_to_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_right_barrel_roll_up_to_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_barrel_roll_up_to_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_barrel_roll_up_to_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_left_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_barrel_roll_down_to_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_barrel_roll_down_to_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                          METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_right_barrel_roll_down_to_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_barrel_roll_down_to_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_barrel_roll_down_to_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_powered_lift(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_powered_lift(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_powered_lift(session, rideIndex, trackSequence, direction, height, tileElement,
                                           METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_left_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_large_half_loop_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_large_half_loop_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                      METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_right_large_half_loop_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_large_half_loop_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_large_half_loop_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_right_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_right_large_half_loop_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_right_large_half_loop_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                         METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_left_large_half_loop_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_left_large_half_loop_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bolliger_mabillard_track_left_large_half_loop_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                        METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_90_deg_to_inverted_flat_quarter_loop_up(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_90_deg_to_inverted_flat_quarter_loop_up(session, rideIndex, trackSequence, direction, height,
-                                                                     mapElement, METAL_SUPPORTS_BOXED);
+                                                                     tileElement, METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_inverted_flat_to_90_deg_quarter_loop_down(paint_session * session, uint8 rideIndex,
                                                                              uint8 trackSequence, uint8 direction,
-                                                                             sint32 height, rct_tile_element * mapElement)
+                                                                             sint32 height, rct_tile_element * tileElement)
 {
     bolliger_mabillard_track_inverted_flat_to_90_deg_quarter_loop_down(session, rideIndex, trackSequence, direction, height,
-                                                                       mapElement, METAL_SUPPORTS_BOXED);
+                                                                       tileElement, METAL_SUPPORTS_BOXED);
 }
 
 static void vertical_drop_rc_track_booster(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    bolliger_mabillard_track_booster(session, rideIndex, trackSequence, direction, height, mapElement, METAL_SUPPORTS_BOXED);
+    bolliger_mabillard_track_booster(session, rideIndex, trackSequence, direction, height, tileElement, METAL_SUPPORTS_BOXED);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_vertical_drop_rc(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/coaster/VirginiaReel.cpp b/src/openrct2/ride/coaster/VirginiaReel.cpp
index 109a581ed0..d2cf8efef5 100644
--- a/src/openrct2/ride/coaster/VirginiaReel.cpp
+++ b/src/openrct2/ride/coaster/VirginiaReel.cpp
@@ -231,10 +231,10 @@ void vehicle_visual_virginia_reel(paint_session * session, sint32 x, sint32 imag
 
 /** rct2: 0x00811264 */
 static void paint_virginia_reel_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     const uint32 * sprites = virginia_reel_track_pieces_flat;
-    if (mapElement->type & 0x80)
+    if (tileElement->type & 0x80)
     {
         sprites = virginia_reel_track_pieces_flat_lift_hill;
     }
@@ -259,10 +259,10 @@ static void paint_virginia_reel_track_flat(paint_session * session, uint8 rideIn
 
 /** rct2: 0x00811274 */
 static void paint_virginia_reel_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     const uint32 * sprites = virginia_reel_track_pieces_25_deg_up;
-    if (mapElement->type & 0x80)
+    if (tileElement->type & 0x80)
     {
         sprites = virginia_reel_track_pieces_25_deg_up_lift_hill;
     }
@@ -310,10 +310,10 @@ static void paint_virginia_reel_track_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x00811294 */
 static void paint_virginia_reel_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint32 * sprites = virginia_reel_track_pieces_flat_to_25_deg_up;
-    if (mapElement->type & 0x80)
+    if (tileElement->type & 0x80)
     {
         sprites = virginia_reel_track_pieces_flat_to_25_deg_up_lift_hill;
     }
@@ -356,10 +356,10 @@ static void paint_virginia_reel_track_flat_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x00811294 */
 static void paint_virginia_reel_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint32 * sprites = virginia_reel_track_pieces_25_deg_up_to_flat;
-    if (mapElement->type & 0x80)
+    if (tileElement->type & 0x80)
     {
         sprites = virginia_reel_track_pieces_25_deg_up_to_flat_lift_hill;
     }
@@ -407,28 +407,28 @@ static void paint_virginia_reel_track_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x008112A4 */
 static void paint_virginia_reel_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_virginia_reel_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_virginia_reel_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008112B4 */
 static void paint_virginia_reel_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_virginia_reel_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_virginia_reel_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008112C4 */
 static void paint_virginia_reel_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_virginia_reel_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_virginia_reel_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008112D4, 0x008112E4, 0x008112F4 */
 static void paint_virginia_reel_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -454,7 +454,7 @@ static void paint_virginia_reel_station(paint_session * session, uint8 rideIndex
     }
 
     wooden_a_supports_paint_setup(session, (direction & 1), 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -464,7 +464,7 @@ static const uint8 virginia_reel_left_quarter_turn_supports[] = { 5, 2, 3, 4 };
 
 /** rct2: 0x00811304 */
 static void paint_virginia_reel_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_left_quarter_turn_3_tiles_paint(
         session, 2, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -492,16 +492,16 @@ static const uint8 virginia_reel_right_quarter_turn_3_tiles_to_left_turn_map[] =
 
 /** rct2: 0x00811314 */
 static void paint_virginia_reel_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = virginia_reel_right_quarter_turn_3_tiles_to_left_turn_map[trackSequence];
     paint_virginia_reel_track_left_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x00811324 */
 static void paint_virginia_reel_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_left_quarter_turn_1_tile_paint(session, 2, height, 0, direction, session->TrackColours[SCHEME_TRACK],
                                                     virginia_reel_track_pieces_flat_quarter_turn_1_tile,
@@ -533,10 +533,10 @@ static void paint_virginia_reel_track_left_quarter_turn_1_tile(paint_session * s
 
 /** rct2: 0x00811334 */
 static void paint_virginia_reel_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     paint_virginia_reel_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /**
diff --git a/src/openrct2/ride/coaster/WildMouse.cpp b/src/openrct2/ride/coaster/WildMouse.cpp
index 4d1bacb596..5e1e7e54a5 100644
--- a/src/openrct2/ride/coaster/WildMouse.cpp
+++ b/src/openrct2/ride/coaster/WildMouse.cpp
@@ -171,7 +171,7 @@ static const uint32 _wild_mouse_block_brakes_image_ids[4] = {
 
 /** rct2: 0x0078B1E4 */
 static void wild_mouse_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                  rct_tile_element * mapElement)
+                                  rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_FLAT_SW_NE, SPR_WILD_MOUSE_FLAT_CHAIN_SW_NE },
@@ -180,7 +180,7 @@ static void wild_mouse_track_flat(paint_session * session, uint8 rideIndex, uint
         { SPR_WILD_MOUSE_FLAT_NW_SE, SPR_WILD_MOUSE_FLAT_CHAIN_SE_NW },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
     if (track_paint_util_should_paint_supports(session->MapPosition))
@@ -194,7 +194,7 @@ static void wild_mouse_track_flat(paint_session * session, uint8 rideIndex, uint
 }
 
 static void wild_mouse_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 baseImageIds[4] = {
         SPR_STATION_BASE_B_SW_NE,
@@ -203,7 +203,7 @@ static void wild_mouse_track_station(paint_session * session, uint8 rideIndex, u
         SPR_STATION_BASE_B_NW_SE,
     };
 
-    sint32 trackType = mapElement->properties.track.type;
+    sint32 trackType = tileElement->properties.track.type;
     sub_98197C_rotated(session, direction, baseImageIds[direction] | session->TrackColours[SCHEME_MISC], 0, 0, 32, 28, 2,
                        height - 2, 0, 2, height);
     if (trackType == TRACK_ELEM_END_STATION)
@@ -218,7 +218,7 @@ static void wild_mouse_track_station(paint_session * session, uint8 rideIndex, u
                            0, 32, 20, 2, height, 0, 0, height);
     }
     track_paint_util_draw_station_metal_supports(session, direction, height, session->TrackColours[SCHEME_SUPPORTS]);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -226,7 +226,7 @@ static void wild_mouse_track_station(paint_session * session, uint8 rideIndex, u
 
 /** rct2: 0x0078B1F4 */
 static void wild_mouse_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_25_DEG_SW_NE, SPR_WILD_MOUSE_25_DEG_CHAIN_SW_NE },
@@ -235,7 +235,7 @@ static void wild_mouse_track_25_deg_up(paint_session * session, uint8 rideIndex,
         { SPR_WILD_MOUSE_25_DEG_SE_NW, SPR_WILD_MOUSE_25_DEG_CHAIN_SE_NW },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
     if (track_paint_util_should_paint_supports(session->MapPosition))
@@ -257,7 +257,7 @@ static void wild_mouse_track_25_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x0078B204 */
 static void wild_mouse_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_60_DEG_SW_NE, SPR_WILD_MOUSE_60_DEG_CHAIN_SW_NE },
@@ -266,7 +266,7 @@ static void wild_mouse_track_60_deg_up(paint_session * session, uint8 rideIndex,
         { SPR_WILD_MOUSE_60_DEG_SE_NW, SPR_WILD_MOUSE_60_DEG_CHAIN_SE_NW },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     if (direction == 0 || direction == 3)
     {
@@ -302,7 +302,7 @@ static void wild_mouse_track_60_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x0078B214 */
 static void wild_mouse_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_FLAT_TO_25_DEG_SW_NE, SPR_WILD_MOUSE_FLAT_TO_25_DEG_CHAIN_SW_NE },
@@ -311,7 +311,7 @@ static void wild_mouse_track_flat_to_25_deg_up(paint_session * session, uint8 ri
         { SPR_WILD_MOUSE_FLAT_TO_25_DEG_SE_NW, SPR_WILD_MOUSE_FLAT_TO_25_DEG_CHAIN_SE_NW },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
     if (track_paint_util_should_paint_supports(session->MapPosition))
@@ -333,7 +333,7 @@ static void wild_mouse_track_flat_to_25_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x0078B224 */
 static void wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_25_DEG_TO_60_DEG_SW_NE, SPR_WILD_MOUSE_25_DEG_TO_60_DEG_CHAIN_SW_NE },
@@ -348,7 +348,7 @@ static void wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * session, uin
         { 0, 0 },
     };
 
-    uint8  isChained    = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained    = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId      = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = frontImageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     if (direction == 0 || direction == 3)
@@ -379,7 +379,7 @@ static void wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * session, uin
 
 /** rct2: 0x0078B234 */
 static void wild_mouse_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_60_DEG_TO_25_DEG_SW_NE, SPR_WILD_MOUSE_60_DEG_TO_25_DEG_CHAIN_SW_NE },
@@ -394,7 +394,7 @@ static void wild_mouse_track_60_deg_up_to_25_deg_up(paint_session * session, uin
         { 0, 0 },
     };
 
-    uint8  isChained    = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained    = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId      = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = frontImageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     if (direction == 0 || direction == 3)
@@ -425,7 +425,7 @@ static void wild_mouse_track_60_deg_up_to_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x0078B244 */
 static void wild_mouse_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_25_DEG_TO_FLAT_SW_NE, SPR_WILD_MOUSE_25_DEG_TO_FLAT_CHAIN_SW_NE },
@@ -434,7 +434,7 @@ static void wild_mouse_track_25_deg_up_to_flat(paint_session * session, uint8 ri
         { SPR_WILD_MOUSE_25_DEG_TO_FLAT_SE_NW, SPR_WILD_MOUSE_25_DEG_TO_FLAT_CHAIN_SE_NW },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
     if (track_paint_util_should_paint_supports(session->MapPosition))
@@ -456,48 +456,48 @@ static void wild_mouse_track_25_deg_up_to_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x0078B254 */
 static void wild_mouse_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wild_mouse_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0078B264 */
 static void wild_mouse_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wild_mouse_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0078B274 */
 static void wild_mouse_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wild_mouse_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0078B284 */
 static void wild_mouse_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wild_mouse_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0078B294 */
 static void wild_mouse_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wild_mouse_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0078B2A4 */
 static void wild_mouse_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wild_mouse_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void wild_mouse_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][3] = {
         {
@@ -552,7 +552,7 @@ static void wild_mouse_track_right_quarter_turn_3(paint_session * session, uint8
 }
 
 static void wild_mouse_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][2] = {
         {
@@ -609,16 +609,16 @@ static void wild_mouse_track_right_quarter_turn_3_25_deg_down(paint_session * se
 }
 
 static void wild_mouse_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     wild_mouse_track_right_quarter_turn_3_25_deg_down(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 /** rct2: 0x0078B314 */
 static void wild_mouse_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][2] = {
         {
@@ -684,22 +684,22 @@ static void wild_mouse_track_right_quarter_turn_3_25_deg_up(paint_session * sess
 
 /** rct2: 0x0078B324 */
 static void wild_mouse_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    wild_mouse_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    wild_mouse_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 static void wild_mouse_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    wild_mouse_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    wild_mouse_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 /** rct2: 0x0078B394 */
 static void wild_mouse_track_left_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4] = {
         SPR_WILD_MOUSE_QUARTER_TURN_1_SW_NE,
@@ -733,14 +733,14 @@ static void wild_mouse_track_left_quarter_turn_1(paint_session * session, uint8
 
 /** rct2: 0x0078B3A4 */
 static void wild_mouse_track_right_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wild_mouse_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x0078B354 */
 static void wild_mouse_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_FLAT_TO_60_DEG_SW_NE, SPR_WILD_MOUSE_FLAT_TO_60_DEG_CHAIN_SW_NE },
@@ -755,7 +755,7 @@ static void wild_mouse_track_flat_to_60_deg_up(paint_session * session, uint8 ri
         { 0, 0 },
     };
 
-    uint8  isChained    = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained    = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId      = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = frontImageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     if (direction == 0 || direction == 3)
@@ -786,7 +786,7 @@ static void wild_mouse_track_flat_to_60_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x0078B364 */
 static void wild_mouse_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WILD_MOUSE_60_DEG_TO_FLAT_SW_NE, SPR_WILD_MOUSE_60_DEG_TO_FLAT_CHAIN_SW_NE },
@@ -801,7 +801,7 @@ static void wild_mouse_track_60_deg_up_to_flat(paint_session * session, uint8 ri
         { 0, 0 },
     };
 
-    uint8  isChained    = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained    = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId      = imageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = frontImageIds[direction][isChained] | session->TrackColours[SCHEME_TRACK];
     if (direction == 0 || direction == 3)
@@ -839,21 +839,21 @@ static void wild_mouse_track_60_deg_up_to_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x0078B374 */
 static void wild_mouse_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wild_mouse_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0078B384 */
 static void wild_mouse_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    wild_mouse_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wild_mouse_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x0078B344 */
 static void wild_mouse_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = _wild_mouse_brakes_image_ids[direction] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
@@ -869,7 +869,7 @@ static void wild_mouse_track_brakes(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x0078B3C4 */
 static void wild_mouse_track_rotation_control_toggle(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4] = {
         SPR_WILD_MOUSE_ROTATION_CONTROL_TOGGLE_SW_NE,
@@ -892,7 +892,7 @@ static void wild_mouse_track_rotation_control_toggle(paint_session * session, ui
 
 /** rct2: 0x0078B3B4 */
 static void wild_mouse_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = _wild_mouse_block_brakes_image_ids[direction] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 3, height, 0, 6, height);
diff --git a/src/openrct2/ride/coaster/WoodenRollerCoaster.cpp b/src/openrct2/ride/coaster/WoodenRollerCoaster.cpp
index 0d7951e07f..07d75050e8 100644
--- a/src/openrct2/ride/coaster/WoodenRollerCoaster.cpp
+++ b/src/openrct2/ride/coaster/WoodenRollerCoaster.cpp
@@ -438,7 +438,7 @@ static void wooden_rc_track_paint_bb(paint_session * session, const sprite_bb_2
 
 /** rct2: 0x008AC568 */
 static void wooden_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WOODEN_RC_FLAT_SW_NE, SPR_WOODEN_RC_FLAT_CHAIN_SW_NE },
@@ -453,7 +453,7 @@ static void wooden_rc_track_flat(paint_session * session, uint8 rideIndex, uint8
         { SPR_WOODEN_RC_FLAT_RAILS_NW_SE, SPR_WOODEN_RC_FLAT_CHAIN_RAILS_SE_NW },
     };
 
-    uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     wooden_rc_track_paint(session, imageIds[direction][isChained], railsImageIds[direction][isChained], direction, 0, 2, 32, 25,
                           2, height, 0, 3, height);
     wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
@@ -463,7 +463,7 @@ static void wooden_rc_track_flat(paint_session * session, uint8 rideIndex, uint8
 }
 
 static void wooden_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 stationImageIds[4][2] = {
         { SPR_WOODEN_RC_STATION_SW_NE, SPR_WOODEN_RC_STATION_RAILS_SW_NE },
@@ -472,7 +472,7 @@ static void wooden_rc_track_station(paint_session * session, uint8 rideIndex, ui
         { SPR_WOODEN_RC_STATION_NW_SE, SPR_WOODEN_RC_STATION_RAILS_NW_SE },
     };
 
-    sint32 trackType = mapElement->properties.track.type;
+    sint32 trackType = tileElement->properties.track.type;
     if (trackType == TRACK_ELEM_END_STATION)
     {
         wooden_rc_track_paint(session, _wooden_rc_block_brakes_image_ids[direction][0],
@@ -485,7 +485,7 @@ static void wooden_rc_track_station(paint_session * session, uint8 rideIndex, ui
                               height, 0, 2, height);
     }
     wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
-    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, mapElement, 9, 11);
+    track_paint_util_draw_station_2(session, rideIndex, trackSequence, direction, height, tileElement, 9, 11);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -493,7 +493,7 @@ static void wooden_rc_track_station(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008AC578 */
 static void wooden_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][4] = {
         {
@@ -514,7 +514,7 @@ static void wooden_rc_track_25_deg_up(paint_session * session, uint8 rideIndex,
         }
     };
 
-    uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     wooden_rc_track_paint(session, imageIds[isChained][direction][0], imageIds[isChained][direction][1], direction, 0, 0, 32,
                           25, 2, height, 0, 3, height);
     if (direction == 1 || direction == 2)
@@ -539,7 +539,7 @@ static void wooden_rc_track_25_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008AC588 */
 static void wooden_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WOODEN_RC_60_DEG_SW_NE, SPR_WOODEN_RC_60_DEG_RAILS_SW_NE },
@@ -575,7 +575,7 @@ static void wooden_rc_track_60_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008AC598 */
 static void wooden_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][4] = {
         {
@@ -596,7 +596,7 @@ static void wooden_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rid
         }
     };
 
-    uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     wooden_rc_track_paint(session, imageIds[isChained][direction][0], imageIds[isChained][direction][1], direction, 0, 0, 32,
                           25, 2, height, 0, 3, height);
     if (direction == 1 || direction == 2)
@@ -621,7 +621,7 @@ static void wooden_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x008AC5A8 */
 static void wooden_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4] = {
         { SPR_WOODEN_RC_25_DEG_TO_60_DEG_SW_NE, SPR_WOODEN_RC_25_DEG_TO_60_DEG_RAILS_SW_NE, 0, 0 },
@@ -661,7 +661,7 @@ static void wooden_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint
 
 /** rct2: 0x008AC5B8 */
 static void wooden_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4] = {
         { SPR_WOODEN_RC_60_DEG_TO_25_DEG_SW_NE, SPR_WOODEN_RC_60_DEG_TO_25_DEG_RAILS_SW_NE, 0, 0 },
@@ -701,7 +701,7 @@ static void wooden_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x008AC5C8 */
 static void wooden_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][4] = {
         {
@@ -722,7 +722,7 @@ static void wooden_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rid
         }
     };
 
-    uint8 isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8 isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     wooden_rc_track_paint(session, imageIds[isChained][direction][0], imageIds[isChained][direction][1], direction, 0, 0, 32,
                           25, 2, height, 0, 3, height);
     if (direction == 1 || direction == 2)
@@ -747,48 +747,48 @@ static void wooden_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rid
 
 /** rct2: 0x008AC5D8 */
 static void wooden_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC5E8 */
 static void wooden_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC5F8 */
 static void wooden_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC608 */
 static void wooden_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC618 */
 static void wooden_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC628 */
 static void wooden_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void wooden_rc_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb_2 imageIds[2][4][7] = {
         { {
@@ -1032,15 +1032,15 @@ static void wooden_rc_track_right_quarter_turn_5(paint_session * session, uint8
 }
 
 static void wooden_rc_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    wooden_rc_track_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    wooden_rc_track_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC658 */
 static void wooden_rc_track_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4] = {
         { SPR_WOODEN_RC_FLAT_TO_LEFT_BANK_SW_NE, SPR_WOODEN_RC_FLAT_TO_LEFT_BANK_RAILS_SW_NE, 0, 0 },
@@ -1066,7 +1066,7 @@ static void wooden_rc_track_flat_to_left_bank(paint_session * session, uint8 rid
 
 /** rct2: 0x008AC668 */
 static void wooden_rc_track_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4] = {
         { SPR_WOODEN_RC_FLAT_TO_RIGHT_BANK_SW_NE, SPR_WOODEN_RC_FLAT_TO_RIGHT_BANK_RAILS_SW_NE,
@@ -1092,20 +1092,20 @@ static void wooden_rc_track_flat_to_right_bank(paint_session * session, uint8 ri
 
 /** rct2: 0x008AC678 */
 static void wooden_rc_track_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_flat_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_flat_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC688 */
 static void wooden_rc_track_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_flat_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_flat_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void wooden_rc_track_banked_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb_2 imageIds[2][4][7] = {
         { {
@@ -1349,15 +1349,15 @@ static void wooden_rc_track_banked_right_quarter_turn_5(paint_session * session,
 }
 
 static void wooden_rc_track_banked_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    wooden_rc_track_banked_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    wooden_rc_track_banked_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC6B8 */
 static void wooden_rc_track_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4] = {
         { SPR_WOODEN_RC_LEFT_BANK_TO_25_DEG_SW_NE, SPR_WOODEN_RC_LEFT_BANK_TO_25_DEG_RAILS_SW_NE, 0, 0 },
@@ -1390,7 +1390,7 @@ static void wooden_rc_track_left_bank_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x008AC6C8 */
 static void wooden_rc_track_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4] = {
         { SPR_WOODEN_RC_RIGHT_BANK_TO_25_DEG_SW_NE, SPR_WOODEN_RC_RIGHT_BANK_TO_25_DEG_RAILS_SW_NE, 0, 0 },
@@ -1423,7 +1423,7 @@ static void wooden_rc_track_right_bank_to_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x008AC6D8 */
 static void wooden_rc_track_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4] = {
         { SPR_WOODEN_RC_25_DEG_TO_LEFT_BANK_SW_NE, SPR_WOODEN_RC_25_DEG_TO_LEFT_BANK_RAILS_SW_NE, 0, 0 },
@@ -1456,7 +1456,7 @@ static void wooden_rc_track_25_deg_up_to_left_bank(paint_session * session, uint
 
 /** rct2: 0x008AC6E8 */
 static void wooden_rc_track_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4] = {
         { SPR_WOODEN_RC_25_DEG_TO_RIGHT_BANK_SW_NE, SPR_WOODEN_RC_25_DEG_TO_RIGHT_BANK_RAILS_SW_NE, 0, 0 },
@@ -1489,35 +1489,35 @@ static void wooden_rc_track_25_deg_up_to_right_bank(paint_session * session, uin
 
 /** rct2: 0x008AC6F8 */
 static void wooden_rc_track_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_25_deg_up_to_right_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC708 */
 static void wooden_rc_track_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_25_deg_up_to_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC718 */
 static void wooden_rc_track_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_right_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC728 */
 static void wooden_rc_track_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_left_bank_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC738 */
 static void wooden_rc_track_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WOODEN_RC_LEFT_BANK_SW_NE, SPR_WOODEN_RC_LEFT_BANK_RAILS_SW_NE },
@@ -1536,14 +1536,14 @@ static void wooden_rc_track_left_bank(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008AC748 */
 static void wooden_rc_track_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_left_bank(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC758 */
 static void wooden_rc_track_left_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1804,7 +1804,7 @@ static void wooden_rc_track_left_quarter_turn_5_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008AC768 */
 static void wooden_rc_track_right_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2065,23 +2065,23 @@ static void wooden_rc_track_right_quarter_turn_5_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008AC778 */
 static void wooden_rc_track_left_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    wooden_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    wooden_rc_track_right_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC788 */
 static void wooden_rc_track_right_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    wooden_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wooden_rc_track_left_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC798 */
 static void wooden_rc_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2281,7 +2281,7 @@ static void wooden_rc_track_s_bend_left(paint_session * session, uint8 rideIndex
 
 /** rct2: 0x008AC7A8 */
 static void wooden_rc_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2481,7 +2481,7 @@ static void wooden_rc_track_s_bend_right(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008ACE18 */
 static void wooden_rc_track_left_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2691,7 +2691,7 @@ static void wooden_rc_track_left_vertical_loop(paint_session * session, uint8 ri
 
 /** rct2: 0x008ACE28 */
 static void wooden_rc_track_right_vertical_loop(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -2875,7 +2875,7 @@ static void wooden_rc_track_right_vertical_loop(paint_session * session, uint8 r
 
 /** rct2: 0x008AC7E8 */
 static void wooden_rc_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3026,15 +3026,15 @@ static void wooden_rc_track_left_quarter_turn_3(paint_session * session, uint8 r
 
 /** rct2: 0x008AC7F8 */
 static void wooden_rc_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    wooden_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wooden_rc_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC808 */
 static void wooden_rc_track_left_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3185,15 +3185,15 @@ static void wooden_rc_track_left_quarter_turn_3_bank(paint_session * session, ui
 
 /** rct2: 0x008AC818 */
 static void wooden_rc_track_right_quarter_turn_3_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    wooden_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wooden_rc_track_left_quarter_turn_3_bank(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC828 */
 static void wooden_rc_track_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3313,7 +3313,7 @@ static void wooden_rc_track_left_quarter_turn_3_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008AC838 */
 static void wooden_rc_track_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3433,23 +3433,23 @@ static void wooden_rc_track_right_quarter_turn_3_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008AC848 */
 static void wooden_rc_track_left_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    wooden_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    wooden_rc_track_right_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC858 */
 static void wooden_rc_track_right_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    wooden_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wooden_rc_track_left_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACAB8 */
 static void wooden_rc_track_left_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -3788,7 +3788,7 @@ static void wooden_rc_track_left_half_banked_helix_up_small(paint_session * sess
 
 /** rct2: 0x008ACAC8 */
 static void wooden_rc_track_right_half_banked_helix_up_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4127,7 +4127,7 @@ static void wooden_rc_track_right_half_banked_helix_up_small(paint_session * ses
 
 /** rct2: 0x008ACAD8 */
 static void wooden_rc_track_left_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -4136,12 +4136,12 @@ static void wooden_rc_track_left_half_banked_helix_down_small(paint_session * se
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     wooden_rc_track_right_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008ACAE8 */
 static void wooden_rc_track_right_half_banked_helix_down_small(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 4)
     {
@@ -4149,12 +4149,12 @@ static void wooden_rc_track_right_half_banked_helix_down_small(paint_session * s
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    wooden_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wooden_rc_track_left_half_banked_helix_up_small(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACAF8 */
 static void wooden_rc_track_left_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -4673,7 +4673,7 @@ static void wooden_rc_track_left_half_banked_helix_up_large(paint_session * sess
 
 /** rct2: 0x008ACB08 */
 static void wooden_rc_track_right_half_banked_helix_up_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5192,7 +5192,7 @@ static void wooden_rc_track_right_half_banked_helix_up_large(paint_session * ses
 
 /** rct2: 0x008ACB18 */
 static void wooden_rc_track_left_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -5201,12 +5201,12 @@ static void wooden_rc_track_left_half_banked_helix_down_large(paint_session * se
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     wooden_rc_track_right_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x008ACB28 */
 static void wooden_rc_track_right_half_banked_helix_down_large(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence >= 7)
     {
@@ -5214,12 +5214,12 @@ static void wooden_rc_track_right_half_banked_helix_down_large(paint_session * s
         direction = (direction + 1) & 3;
     }
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    wooden_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wooden_rc_track_left_half_banked_helix_up_large(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACB98 */
 static void wooden_rc_track_left_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -5271,7 +5271,7 @@ static void wooden_rc_track_left_quarter_turn_1_60_deg_up(paint_session * sessio
 
 /** rct2: 0x008ACB78 */
 static void wooden_rc_track_right_quarter_turn_1_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -5323,21 +5323,21 @@ static void wooden_rc_track_right_quarter_turn_1_60_deg_up(paint_session * sessi
 
 /** rct2: 0x008ACB88 */
 static void wooden_rc_track_left_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);
+    wooden_rc_track_right_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACBA8 */
 static void wooden_rc_track_right_quarter_turn_1_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wooden_rc_track_left_quarter_turn_1_60_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC868 */
 static void wooden_rc_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WOODEN_RC_BRAKES_SW_NE, SPR_WOODEN_RC_BRAKES_RAILS_SW_NE },
@@ -5356,7 +5356,7 @@ static void wooden_rc_track_brakes(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x008ACC78 */
 static void wooden_rc_track_25_deg_up_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -5411,7 +5411,7 @@ static void wooden_rc_track_25_deg_up_left_banked(paint_session * session, uint8
 
 /** rct2: 0x008ACC88 */
 static void wooden_rc_track_25_deg_up_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -5466,7 +5466,7 @@ static void wooden_rc_track_25_deg_up_right_banked(paint_session * session, uint
 
 /** rct2: 0x008AC878 */
 static void wooden_rc_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -5496,7 +5496,7 @@ static void wooden_rc_track_on_ride_photo(paint_session * session, uint8 rideInd
         break;
     }
     wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
-    track_paint_util_onride_photo_small_paint(session, direction, height + 16, mapElement);
+    track_paint_util_onride_photo_small_paint(session, direction, height + 16, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 48, 0x20);
@@ -5504,21 +5504,21 @@ static void wooden_rc_track_on_ride_photo(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008ACC98 */
 static void wooden_rc_track_25_deg_down_left_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_25_deg_up_right_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACCA8 */
 static void wooden_rc_track_25_deg_down_right_banked(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_25_deg_up_left_banked(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACE08 */
 static void wooden_rc_track_water_splash(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -5859,7 +5859,7 @@ static void wooden_rc_track_water_splash(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008AC958 */
 static void wooden_rc_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6059,7 +6059,7 @@ static void wooden_rc_track_left_eighth_to_diag(paint_session * session, uint8 r
 
 /** rct2: 0x008AC968 */
 static void wooden_rc_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6259,23 +6259,23 @@ static void wooden_rc_track_right_eighth_to_diag(paint_session * session, uint8
 
 /** rct2: 0x008AC978 */
 static void wooden_rc_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    wooden_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC988 */
 static void wooden_rc_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    wooden_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    wooden_rc_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC998 */
 static void wooden_rc_track_left_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6475,7 +6475,7 @@ static void wooden_rc_track_left_eighth_bank_to_diag(paint_session * session, ui
 
 /** rct2: 0x008AC9A8 */
 static void wooden_rc_track_right_eighth_bank_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -6675,28 +6675,28 @@ static void wooden_rc_track_right_eighth_bank_to_diag(paint_session * session, u
 
 /** rct2: 0x008AC9B8 */
 static void wooden_rc_track_left_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    wooden_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_right_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC9C8 */
 static void wooden_rc_track_right_eighth_bank_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    wooden_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    wooden_rc_track_left_eighth_bank_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008AC888 */
 static void wooden_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6724,7 +6724,7 @@ static void wooden_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6780,7 +6780,7 @@ static void wooden_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6836,7 +6836,7 @@ static void wooden_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
         paint_util_set_general_support_height(session, height + 32, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6868,12 +6868,12 @@ static void wooden_rc_track_diag_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008AC8B8 */
 static void wooden_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6901,7 +6901,7 @@ static void wooden_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -6957,7 +6957,7 @@ static void wooden_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7013,7 +7013,7 @@ static void wooden_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7045,7 +7045,7 @@ static void wooden_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008AC8E8 */
 static void wooden_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7134,12 +7134,12 @@ static void wooden_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008AC898 */
 static void wooden_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7167,7 +7167,7 @@ static void wooden_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7223,7 +7223,7 @@ static void wooden_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7279,7 +7279,7 @@ static void wooden_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7311,7 +7311,7 @@ static void wooden_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x008AC8C8 */
 static void wooden_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7400,7 +7400,7 @@ static void wooden_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session,
 
 /** rct2: 0x008AC8D8 */
 static void wooden_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7489,12 +7489,12 @@ static void wooden_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008AC8A8 */
 static void wooden_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7522,7 +7522,7 @@ static void wooden_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7578,7 +7578,7 @@ static void wooden_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7634,7 +7634,7 @@ static void wooden_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7666,12 +7666,12 @@ static void wooden_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint
 
 /** rct2: 0x008AC918 */
 static void wooden_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7699,7 +7699,7 @@ static void wooden_rc_track_diag_25_deg_down(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7755,7 +7755,7 @@ static void wooden_rc_track_diag_25_deg_down(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7811,7 +7811,7 @@ static void wooden_rc_track_diag_25_deg_down(paint_session * session, uint8 ride
         paint_util_set_general_support_height(session, height + 56, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7843,7 +7843,7 @@ static void wooden_rc_track_diag_25_deg_down(paint_session * session, uint8 ride
 
 /** rct2: 0x008AC948 */
 static void wooden_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -7932,12 +7932,12 @@ static void wooden_rc_track_diag_60_deg_down(paint_session * session, uint8 ride
 
 /** rct2: 0x008AC8F8 */
 static void wooden_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -7963,7 +7963,7 @@ static void wooden_rc_track_diag_flat_to_25_deg_down(paint_session * session, ui
         }
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -8017,7 +8017,7 @@ static void wooden_rc_track_diag_flat_to_25_deg_down(paint_session * session, ui
         }
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -8071,7 +8071,7 @@ static void wooden_rc_track_diag_flat_to_25_deg_down(paint_session * session, ui
         }
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -8104,7 +8104,7 @@ static void wooden_rc_track_diag_flat_to_25_deg_down(paint_session * session, ui
 
 /** rct2: 0x008AC928 */
 static void wooden_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8193,7 +8193,7 @@ static void wooden_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * sess
 
 /** rct2: 0x008AC938 */
 static void wooden_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8282,12 +8282,12 @@ static void wooden_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * sess
 
 /** rct2: 0x008AC908 */
 static void wooden_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
     case 0:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -8315,7 +8315,7 @@ static void wooden_rc_track_diag_25_deg_down_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 1:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -8371,7 +8371,7 @@ static void wooden_rc_track_diag_25_deg_down_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 2:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -8427,7 +8427,7 @@ static void wooden_rc_track_diag_25_deg_down_to_flat(paint_session * session, ui
         paint_util_set_general_support_height(session, height + 48, 0x20);
         break;
     case 3:
-        if (track_element_is_lift_hill(mapElement))
+        if (track_element_is_lift_hill(tileElement))
         {
             switch (direction)
             {
@@ -8459,7 +8459,7 @@ static void wooden_rc_track_diag_25_deg_down_to_flat(paint_session * session, ui
 
 /** rct2: 0x008ACA18 */
 static void wooden_rc_track_diag_flat_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8548,7 +8548,7 @@ static void wooden_rc_track_diag_flat_to_left_bank(paint_session * session, uint
 
 /** rct2: 0x008AC9F8 */
 static void wooden_rc_track_diag_flat_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8637,7 +8637,7 @@ static void wooden_rc_track_diag_flat_to_right_bank(paint_session * session, uin
 
 /** rct2: 0x008ACA08 */
 static void wooden_rc_track_diag_left_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8726,7 +8726,7 @@ static void wooden_rc_track_diag_left_bank_to_flat(paint_session * session, uint
 
 /** rct2: 0x008ACA28 */
 static void wooden_rc_track_diag_right_bank_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8815,7 +8815,7 @@ static void wooden_rc_track_diag_right_bank_to_flat(paint_session * session, uin
 
 /** rct2: 0x008ACA58 */
 static void wooden_rc_track_diag_left_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8904,7 +8904,7 @@ static void wooden_rc_track_diag_left_bank_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008ACA68 */
 static void wooden_rc_track_diag_right_bank_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -8993,7 +8993,7 @@ static void wooden_rc_track_diag_right_bank_to_25_deg_up(paint_session * session
 
 /** rct2: 0x008ACA38 */
 static void wooden_rc_track_diag_25_deg_up_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9082,7 +9082,7 @@ static void wooden_rc_track_diag_25_deg_up_to_left_bank(paint_session * session,
 
 /** rct2: 0x008ACA48 */
 static void wooden_rc_track_diag_25_deg_up_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9171,7 +9171,7 @@ static void wooden_rc_track_diag_25_deg_up_to_right_bank(paint_session * session
 
 /** rct2: 0x008ACA78 */
 static void wooden_rc_track_diag_left_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9255,7 +9255,7 @@ static void wooden_rc_track_diag_left_bank_to_25_deg_down(paint_session * sessio
 
 /** rct2: 0x008ACA88 */
 static void wooden_rc_track_diag_right_bank_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9339,7 +9339,7 @@ static void wooden_rc_track_diag_right_bank_to_25_deg_down(paint_session * sessi
 
 /** rct2: 0x008ACA98 */
 static void wooden_rc_track_diag_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9428,7 +9428,7 @@ static void wooden_rc_track_diag_25_deg_down_to_left_bank(paint_session * sessio
 
 /** rct2: 0x008ACAA8 */
 static void wooden_rc_track_diag_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9517,7 +9517,7 @@ static void wooden_rc_track_diag_25_deg_down_to_right_bank(paint_session * sessi
 
 /** rct2: 0x008AC9D8 */
 static void wooden_rc_track_diag_left_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9606,7 +9606,7 @@ static void wooden_rc_track_diag_left_bank(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008AC9E8 */
 static void wooden_rc_track_diag_right_bank(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9696,7 +9696,7 @@ static void wooden_rc_track_diag_right_bank(paint_session * session, uint8 rideI
 /** rct2: 0x008ACB38 */
 static void wooden_rc_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                        uint8 trackSequence, uint8 direction, sint32 height,
-                                                                       rct_tile_element * mapElement)
+                                                                       rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9817,7 +9817,7 @@ static void wooden_rc_track_left_bank_to_left_quarter_turn_3_25_deg_up(paint_ses
 /** rct2: 0x008ACB48 */
 static void wooden_rc_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -9938,7 +9938,7 @@ static void wooden_rc_track_right_bank_to_right_quarter_turn_3_25_deg_up(paint_s
 /** rct2: 0x008ACB58 */
 static void wooden_rc_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_session * session, uint8 rideIndex,
                                                                          uint8 trackSequence, uint8 direction, sint32 height,
-                                                                         rct_tile_element * mapElement)
+                                                                         rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -10059,7 +10059,7 @@ static void wooden_rc_track_left_quarter_turn_3_25_deg_down_to_left_bank(paint_s
 /** rct2: 0x008ACB68 */
 static void wooden_rc_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint_session * session, uint8 rideIndex,
                                                                            uint8 trackSequence, uint8 direction, sint32 height,
-                                                                           rct_tile_element * mapElement)
+                                                                           rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -10179,7 +10179,7 @@ static void wooden_rc_track_right_quarter_turn_3_25_deg_down_to_right_bank(paint
 
 /** rct2: 0x008ACDF8 */
 static void wooden_rc_track_block_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     wooden_rc_track_paint(session, _wooden_rc_block_brakes_image_ids[direction][0],
                           _wooden_rc_block_brakes_image_ids[direction][1], direction, 0, 2, 32, 25, 2, height, 0, 3, height);
@@ -10191,7 +10191,7 @@ static void wooden_rc_track_block_brakes(paint_session * session, uint8 rideInde
 
 /** rct2: 0x008ACCB8 */
 static void wooden_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -10311,7 +10311,7 @@ static void wooden_rc_track_left_banked_quarter_turn_3_25_deg_up(paint_session *
 
 /** rct2: 0x008ACCC8 */
 static void wooden_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -10432,26 +10432,26 @@ static void wooden_rc_track_right_banked_quarter_turn_3_25_deg_up(paint_session
 /** rct2: 0x008ACCD8 */
 static void wooden_rc_track_left_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     wooden_rc_track_right_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x008ACCE8 */
 static void wooden_rc_track_right_banked_quarter_turn_3_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     wooden_rc_track_left_banked_quarter_turn_3_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x008ACC38 */
 static void wooden_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -10712,7 +10712,7 @@ static void wooden_rc_track_left_banked_quarter_turn_5_25_deg_up(paint_session *
 
 /** rct2: 0x008ACC48 */
 static void wooden_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -10974,26 +10974,26 @@ static void wooden_rc_track_right_banked_quarter_turn_5_25_deg_up(paint_session
 /** rct2: 0x008ACC58 */
 static void wooden_rc_track_left_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     wooden_rc_track_right_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction + 1) & 3, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /** rct2: 0x008ACC68 */
 static void wooden_rc_track_right_banked_quarter_turn_5_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     wooden_rc_track_left_banked_quarter_turn_5_25_deg_up(session, rideIndex, trackSequence, (direction - 1) & 3, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 /** rct2: 0x008ACCF8 */
 static void wooden_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11040,7 +11040,7 @@ static void wooden_rc_track_25_deg_up_to_left_banked_25_deg_up(paint_session * s
 
 /** rct2: 0x008ACD08 */
 static void wooden_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11087,7 +11087,7 @@ static void wooden_rc_track_25_deg_up_to_right_banked_25_deg_up(paint_session *
 
 /** rct2: 0x008ACD18 */
 static void wooden_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11134,7 +11134,7 @@ static void wooden_rc_track_left_banked_25_deg_up_to_25_deg_up(paint_session * s
 
 /** rct2: 0x008ACD28 */
 static void wooden_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11182,43 +11182,43 @@ static void wooden_rc_track_right_banked_25_deg_up_to_25_deg_up(paint_session *
 /** rct2: 0x008ACD38 */
 static void wooden_rc_track_25_deg_down_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     wooden_rc_track_right_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008ACD48 */
 static void wooden_rc_track_25_deg_down_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     wooden_rc_track_left_banked_25_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008ACD58 */
 static void wooden_rc_track_left_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     wooden_rc_track_25_deg_up_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /** rct2: 0x008ACD68 */
 static void wooden_rc_track_right_banked_25_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     wooden_rc_track_25_deg_up_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008ACD78 */
 static void wooden_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11274,7 +11274,7 @@ static void wooden_rc_track_left_banked_flat_to_left_banked_25_deg_up(paint_sess
 /** rct2: 0x008ACD88 */
 static void wooden_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11330,7 +11330,7 @@ static void wooden_rc_track_right_banked_flat_to_right_banked_25_deg_up(paint_se
 /** rct2: 0x008ACD98 */
 static void wooden_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                       uint8 trackSequence, uint8 direction, sint32 height,
-                                                                      rct_tile_element * mapElement)
+                                                                      rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11386,7 +11386,7 @@ static void wooden_rc_track_left_banked_25_deg_up_to_left_banked_flat(paint_sess
 /** rct2: 0x008ACDA8 */
 static void wooden_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11442,42 +11442,42 @@ static void wooden_rc_track_right_banked_25_deg_up_to_right_banked_flat(paint_se
 /** rct2: 0x008ACDB8 */
 static void wooden_rc_track_left_banked_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     wooden_rc_track_right_banked_25_deg_up_to_right_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                mapElement);
+                                                                tileElement);
 }
 
 /** rct2: 0x008ACDC8 */
 static void wooden_rc_track_right_banked_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     wooden_rc_track_left_banked_25_deg_up_to_left_banked_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008ACDD8 */
 static void wooden_rc_track_left_banked_25_deg_down_to_left_banked_flat(paint_session * session, uint8 rideIndex,
                                                                         uint8 trackSequence, uint8 direction, sint32 height,
-                                                                        rct_tile_element * mapElement)
+                                                                        rct_tile_element * tileElement)
 {
     wooden_rc_track_right_banked_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                                mapElement);
+                                                                tileElement);
 }
 
 /** rct2: 0x008ACDE8 */
 static void wooden_rc_track_right_banked_25_deg_down_to_right_banked_flat(paint_session * session, uint8 rideIndex,
                                                                           uint8 trackSequence, uint8 direction, sint32 height,
-                                                                          rct_tile_element * mapElement)
+                                                                          rct_tile_element * tileElement)
 {
     wooden_rc_track_left_banked_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                              mapElement);
+                                                              tileElement);
 }
 
 /** rct2: 0x008ACBB8 */
 static void wooden_rc_track_flat_to_left_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11532,7 +11532,7 @@ static void wooden_rc_track_flat_to_left_banked_25_deg_up(paint_session * sessio
 
 /** rct2: 0x008ACBC8 */
 static void wooden_rc_track_flat_to_right_banked_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11587,7 +11587,7 @@ static void wooden_rc_track_flat_to_right_banked_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008ACBD8 */
 static void wooden_rc_track_left_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11642,7 +11642,7 @@ static void wooden_rc_track_left_banked_25_deg_up_to_flat(paint_session * sessio
 
 /** rct2: 0x008ACBE8 */
 static void wooden_rc_track_right_banked_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -11697,30 +11697,30 @@ static void wooden_rc_track_right_banked_25_deg_up_to_flat(paint_session * sessi
 
 /** rct2: 0x008ACBF8 */
 static void wooden_rc_track_flat_to_left_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_right_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACC08 */
 static void wooden_rc_track_flat_to_right_banked_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_left_banked_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACC18 */
 static void wooden_rc_track_left_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_flat_to_right_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008ACC28 */
 static void wooden_rc_track_right_banked_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_rc_track_flat_to_left_banked_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_wooden_rc(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/coaster/WoodenWildMouse.cpp b/src/openrct2/ride/coaster/WoodenWildMouse.cpp
index 6f572e3674..737900fbad 100644
--- a/src/openrct2/ride/coaster/WoodenWildMouse.cpp
+++ b/src/openrct2/ride/coaster/WoodenWildMouse.cpp
@@ -130,7 +130,7 @@ enum
 
 /** rct2: 0x008A5464 */
 static void wooden_wild_mouse_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4] = {
         SPR_WOODEN_WILD_MOUSE_FLAT_SW_NE,
@@ -153,7 +153,7 @@ static void wooden_wild_mouse_track_flat(paint_session * session, uint8 rideInde
 }
 
 static void wooden_wild_mouse_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_WOODEN_WILD_MOUSE_FLAT_SW_NE, SPR_STATION_BASE_B_SW_NE },
@@ -167,7 +167,7 @@ static void wooden_wild_mouse_track_station(paint_session * session, uint8 rideI
     sub_98199C_rotated(session, direction, imageIds[direction][0] | session->TrackColours[SCHEME_TRACK], 0, 6, 32, 20, 1,
                        height, 0, 0, height);
     wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -175,7 +175,7 @@ static void wooden_wild_mouse_track_station(paint_session * session, uint8 rideI
 
 /** rct2: 0x008A5474 */
 static void wooden_wild_mouse_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4] = {
         {
@@ -192,7 +192,7 @@ static void wooden_wild_mouse_track_25_deg_up(paint_session * session, uint8 rid
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[isChained][direction] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 2, 32, 25, 1, height, 0, 3, height);
 
@@ -213,7 +213,7 @@ static void wooden_wild_mouse_track_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x008A5484 */
 static void wooden_wild_mouse_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4] = {
         {
@@ -230,7 +230,7 @@ static void wooden_wild_mouse_track_60_deg_up(paint_session * session, uint8 rid
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[isChained][direction] | session->TrackColours[SCHEME_TRACK];
     if (direction == 0 || direction == 3)
     {
@@ -259,7 +259,7 @@ static void wooden_wild_mouse_track_60_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x008A5494 */
 static void wooden_wild_mouse_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4] = {
         {
@@ -276,7 +276,7 @@ static void wooden_wild_mouse_track_flat_to_25_deg_up(paint_session * session, u
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[isChained][direction] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 2, 32, 25, 1, height, 0, 3, height);
 
@@ -297,7 +297,7 @@ static void wooden_wild_mouse_track_flat_to_25_deg_up(paint_session * session, u
 
 /** rct2: 0x008A54A4 */
 static void wooden_wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][2] = {
         {
@@ -314,7 +314,7 @@ static void wooden_wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * sessi
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId;
     if (direction == 0 || direction == 3)
     {
@@ -346,7 +346,7 @@ static void wooden_wild_mouse_track_25_deg_up_to_60_deg_up(paint_session * sessi
 }
 
 static void wooden_wild_mouse_track_60_deg_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][2] = {
         {
@@ -363,7 +363,7 @@ static void wooden_wild_mouse_track_60_deg_to_25_deg_up(paint_session * session,
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId;
     if (direction == 0 || direction == 3)
     {
@@ -396,7 +396,7 @@ static void wooden_wild_mouse_track_60_deg_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008A54C4 */
 static void wooden_wild_mouse_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4] = {
         {
@@ -413,7 +413,7 @@ static void wooden_wild_mouse_track_25_deg_up_to_flat(paint_session * session, u
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[isChained][direction] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 2, 32, 25, 1, height, 0, 3, height);
 
@@ -434,48 +434,48 @@ static void wooden_wild_mouse_track_25_deg_up_to_flat(paint_session * session, u
 
 /** rct2: 0x008A54D4 */
 static void wooden_wild_mouse_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_wild_mouse_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A54E4 */
 static void wooden_wild_mouse_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_wild_mouse_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A54F4 */
 static void wooden_wild_mouse_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_wild_mouse_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5504 */
 static void wooden_wild_mouse_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_60_deg_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_wild_mouse_track_60_deg_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5514 */
 static void wooden_wild_mouse_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_wild_mouse_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5524 */
 static void wooden_wild_mouse_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_wild_mouse_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void wooden_wild_mouse_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][3] = {
         {
@@ -531,14 +531,14 @@ static void wooden_wild_mouse_track_right_quarter_turn_3(paint_session * session
 }
 
 static void wooden_wild_mouse_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    wooden_wild_mouse_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    wooden_wild_mouse_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 static void wooden_wild_mouse_track_left_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4] = {
         SPR_WOODEN_WILD_MOUSE_QUARTER_TURN_1_SW_NE,
@@ -572,14 +572,14 @@ static void wooden_wild_mouse_track_left_quarter_turn_1(paint_session * session,
 
 /** rct2: 0x008A55D4 */
 static void wooden_wild_mouse_track_right_quarter_turn_1(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    wooden_wild_mouse_track_left_quarter_turn_1(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A55E4 */
 static void wooden_wild_mouse_track_flat_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][2] = {
         {
@@ -596,7 +596,7 @@ static void wooden_wild_mouse_track_flat_to_60_deg_up(paint_session * session, u
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId;
     if (direction == 0 || direction == 3)
     {
@@ -628,7 +628,7 @@ static void wooden_wild_mouse_track_flat_to_60_deg_up(paint_session * session, u
 
 /** rct2: 0x008A55F4 */
 static void wooden_wild_mouse_track_60_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][2] = {
         {
@@ -645,7 +645,7 @@ static void wooden_wild_mouse_track_60_deg_up_to_flat(paint_session * session, u
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId;
     if (direction == 0 || direction == 3)
     {
@@ -677,16 +677,16 @@ static void wooden_wild_mouse_track_60_deg_up_to_flat(paint_session * session, u
 
 /** rct2: 0x008A5604 */
 static void wooden_wild_mouse_track_flat_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_wild_mouse_track_60_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x008A5614 */
 static void wooden_wild_mouse_track_60_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    wooden_wild_mouse_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    wooden_wild_mouse_track_flat_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_wooden_wild_mouse(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/gentle/CarRide.cpp b/src/openrct2/ride/gentle/CarRide.cpp
index b06e0a8b37..6bd540f509 100644
--- a/src/openrct2/ride/gentle/CarRide.cpp
+++ b/src/openrct2/ride/gentle/CarRide.cpp
@@ -152,7 +152,7 @@ static const uint32 car_ride_track_pieces_quarter_turn_3_tiles[4][3] = {
 
 /** rct2: 0x006F72C8 */
 static void paint_car_ride_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = car_ride_track_pieces_flat[direction] | session->TrackColours[SCHEME_TRACK];
 
@@ -182,7 +182,7 @@ static void paint_car_ride_track_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x006F72D8 */
 static void paint_car_ride_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = car_ride_track_pieces_25_deg_up[direction] | session->TrackColours[SCHEME_TRACK];
 
@@ -219,7 +219,7 @@ static void paint_car_ride_track_25_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x006F72E8 */
 static void paint_car_ride_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = car_ride_track_pieces_flat_to_25_deg_up[direction] | session->TrackColours[SCHEME_TRACK];
 
@@ -256,7 +256,7 @@ static void paint_car_ride_track_flat_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x006F72F8 */
 static void paint_car_ride_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = car_ride_track_pieces_25_deg_up_to_flat[direction] | session->TrackColours[SCHEME_TRACK];
 
@@ -293,28 +293,28 @@ static void paint_car_ride_track_25_deg_up_to_flat(paint_session * session, uint
 
 /** rct2: 0x006F7308 */
 static void paint_car_ride_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    paint_car_ride_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_car_ride_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x006F7318 */
 static void paint_car_ride_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_car_ride_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_car_ride_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x006F7328 */
 static void paint_car_ride_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_car_ride_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_car_ride_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x006F7338, 0x006F7348, 0x006F7358 */
 static void paint_car_ride_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -359,7 +359,7 @@ static void paint_car_ride_station(paint_session * session, uint8 rideIndex, uin
         metal_a_supports_paint_setup(session, METAL_SUPPORTS_BOXED, 7, 0, height, session->TrackColours[SCHEME_SUPPORTS]);
     }
 
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -367,7 +367,7 @@ static void paint_car_ride_station(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x006F7378 */
 static void paint_car_ride_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_3_tiles_paint(
         session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -403,15 +403,15 @@ static void paint_car_ride_track_right_quarter_turn_3_tiles(paint_session * sess
 
 /** rct2: 0x006F7368 */
 static void paint_car_ride_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    paint_car_ride_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    paint_car_ride_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 /** rct2: 0x006F7388 */
 static void paint_car_ride_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = car_ride_track_pieces_left_quarter_turn_1_tile[direction] | session->TrackColours[SCHEME_TRACK];
 
@@ -441,14 +441,14 @@ static void paint_car_ride_track_left_quarter_turn_1_tile(paint_session * sessio
 
 /** rct2: 0x006F7398 */
 static void paint_car_ride_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_car_ride_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
+    paint_car_ride_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 /** rct2: 0x006F73A8 */
 static void paint_car_ride_track_spinning_tunnel(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = car_ride_track_pieces_flat[direction] | session->TrackColours[SCHEME_TRACK];
 
@@ -480,7 +480,7 @@ static void paint_car_ride_track_spinning_tunnel(paint_session * session, uint8
 
 /** rct2: 0x006F73B8 */
 static void paint_car_ride_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -530,7 +530,7 @@ static void paint_car_ride_track_60_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x006F73C8 */
 static void paint_car_ride_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -587,7 +587,7 @@ static void paint_car_ride_track_25_deg_up_to_60_deg_up(paint_session * session,
 
 /** rct2: 0x006F73D8 */
 static void paint_car_ride_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -644,28 +644,28 @@ static void paint_car_ride_track_60_deg_up_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x006F73E8 */
 static void paint_car_ride_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    paint_car_ride_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_car_ride_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x006F73F8 */
 static void paint_car_ride_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_car_ride_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_car_ride_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x006F7408 */
 static void paint_car_ride_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_car_ride_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_car_ride_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x006F7418 */
 static void paint_car_ride_track_log_bumps(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = car_ride_track_pieces_log_bumps[direction] | session->TrackColours[SCHEME_TRACK];
 
diff --git a/src/openrct2/ride/gentle/CircusShow.cpp b/src/openrct2/ride/gentle/CircusShow.cpp
index ae7a77c339..0bb2e46383 100644
--- a/src/openrct2/ride/gentle/CircusShow.cpp
+++ b/src/openrct2/ride/gentle/CircusShow.cpp
@@ -25,7 +25,7 @@
  */
 static void paint_circus_show_tent(paint_session * session, uint8 rideIndex, uint8 direction, sint8 al, sint8 cl, uint16 height)
 {
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     Ride *           ride      = get_ride(rideIndex);
     rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
@@ -48,14 +48,14 @@ static void paint_circus_show_tent(paint_session * session, uint8 rideIndex, uin
     sub_98197C(session, imageId | imageColourFlags, al, cl, 24, 24, 47, height + 3, al + 16, cl + 16, height + 3,
                get_current_rotation());
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 /**
  * rct2: 0x0076FAD4
  */
 static void paint_circus_show(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                              rct_tile_element * mapElement)
+                              rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -68,7 +68,7 @@ static void paint_circus_show(paint_session * session, uint8 rideIndex, uint8 tr
     track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
                                  get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
                                   fenceSpritesRope, get_current_rotation());
 
     switch (trackSequence)
diff --git a/src/openrct2/ride/gentle/CrookedHouse.cpp b/src/openrct2/ride/gentle/CrookedHouse.cpp
index f29454f831..0cd9fcd90b 100644
--- a/src/openrct2/ride/gentle/CrookedHouse.cpp
+++ b/src/openrct2/ride/gentle/CrookedHouse.cpp
@@ -69,7 +69,7 @@ static void paint_crooked_house_structure(paint_session * session, uint8 directi
 }
 
 static void paint_crooked_house(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                rct_tile_element * mapElement)
+                                rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -82,7 +82,7 @@ static void paint_crooked_house(paint_session * session, uint8 rideIndex, uint8
     track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
                                  get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
                                   fenceSpritesRope, get_current_rotation());
 
     switch (trackSequence)
diff --git a/src/openrct2/ride/gentle/Dodgems.cpp b/src/openrct2/ride/gentle/Dodgems.cpp
index f2ed194fba..d982022aa4 100644
--- a/src/openrct2/ride/gentle/Dodgems.cpp
+++ b/src/openrct2/ride/gentle/Dodgems.cpp
@@ -44,7 +44,7 @@ static void paint_dodgems_roof(paint_session * session, sint32 height, sint32 of
 }
 
 static void paint_dodgems(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                          rct_tile_element * mapElement)
+                          rct_tile_element * tileElement)
 {
     uint8 relativeTrackSequence = track_map_4x4[direction][trackSequence];
 
@@ -57,7 +57,7 @@ static void paint_dodgems(paint_session * session, uint8 rideIndex, uint8 trackS
     uint32 imageId = SPR_DODGEMS_FLOOR | session->TrackColours[SCHEME_SUPPORTS];
     sub_98197C(session, imageId, 0, 0, 30, 30, 1, height, 1, 1, height, get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
                                   dodgems_fence_sprites, get_current_rotation());
 
     switch (direction)
diff --git a/src/openrct2/ride/gentle/FerrisWheel.cpp b/src/openrct2/ride/gentle/FerrisWheel.cpp
index ed2f9a7344..d3f1b9a005 100644
--- a/src/openrct2/ride/gentle/FerrisWheel.cpp
+++ b/src/openrct2/ride/gentle/FerrisWheel.cpp
@@ -58,7 +58,7 @@ static void paint_ferris_wheel_structure(paint_session * session, uint8 rideInde
 {
     uint32 imageId, baseImageId;
 
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     Ride *           ride      = get_ride(rideIndex);
     rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
@@ -130,7 +130,7 @@ static void paint_ferris_wheel_structure(paint_session * session, uint8 rideInde
     sub_98199C(session, imageId, xOffset, yOffset, boundBox.length_x, boundBox.length_y, 127, height, boundBox.offset_x,
                boundBox.offset_y, height, get_current_rotation());
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
@@ -138,7 +138,7 @@ static void paint_ferris_wheel_structure(paint_session * session, uint8 rideInde
  * rct2: 0x008A8EC4
  */
 static void paint_ferris_wheel(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                               rct_tile_element * mapElement)
+                               rct_tile_element * tileElement)
 {
     uint8 relativeTrackSequence = track_map_1x4[direction][trackSequence];
 
@@ -163,23 +163,23 @@ static void paint_ferris_wheel(paint_session * session, uint8 rideIndex, uint8 t
     uint32 imageId;
     uint8  rotation    = get_current_rotation();
     uint32 colourFlags = session->TrackColours[SCHEME_MISC];
-    if (edges & EDGE_NW && track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, rotation))
+    if (edges & EDGE_NW && track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, rotation))
     {
         imageId = SPR_FENCE_ROPE_NW | colourFlags;
         sub_98199C(session, imageId, 0, 0, 32, 1, 7, height, 0, 2, height + 2, rotation);
     }
-    if (edges & EDGE_NE && track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, rotation))
+    if (edges & EDGE_NE && track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, rotation))
     {
         imageId = SPR_FENCE_ROPE_NE | colourFlags;
         sub_98199C(session, imageId, 0, 0, 1, 32, 7, height, 2, 0, height + 2, rotation);
     }
-    if (edges & EDGE_SE && track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, rotation))
+    if (edges & EDGE_SE && track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, rotation))
     {
         // Bound box is slightly different from track_paint_util_paint_fences
         imageId = SPR_FENCE_ROPE_SE | colourFlags;
         sub_98197C(session, imageId, 0, 0, 28, 1, 7, height, 0, 29, height + 3, rotation);
     }
-    if (edges & EDGE_SW && track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, rotation))
+    if (edges & EDGE_SW && track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, rotation))
     {
         imageId = SPR_FENCE_ROPE_SW | colourFlags;
         sub_98197C(session, imageId, 0, 0, 1, 32, 7, height, 30, 0, height + 2, rotation);
diff --git a/src/openrct2/ride/gentle/FlyingSaucers.cpp b/src/openrct2/ride/gentle/FlyingSaucers.cpp
index 9161bc4435..c2f9b90f60 100644
--- a/src/openrct2/ride/gentle/FlyingSaucers.cpp
+++ b/src/openrct2/ride/gentle/FlyingSaucers.cpp
@@ -40,7 +40,7 @@ static const uint32 flying_saucers_fence_sprites[] = {
  * rct2: 0x008873D8
  */
 static void paint_flying_saucers(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     uint8 relativeTrackSequence = track_map_4x4[direction][trackSequence];
 
@@ -53,7 +53,7 @@ static void paint_flying_saucers(paint_session * session, uint8 rideIndex, uint8
     uint32 imageId = SPR_FLYING_SAUCERS_FLOOR | session->TrackColours[SCHEME_TRACK];
     sub_98197C(session, imageId, 0, 0, 30, 30, 1, height, 1, 1, height, get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
                                   flying_saucers_fence_sprites, get_current_rotation());
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
diff --git a/src/openrct2/ride/gentle/GhostTrain.cpp b/src/openrct2/ride/gentle/GhostTrain.cpp
index 031d66e74f..db950c77f7 100644
--- a/src/openrct2/ride/gentle/GhostTrain.cpp
+++ b/src/openrct2/ride/gentle/GhostTrain.cpp
@@ -136,7 +136,7 @@ static const uint32 ghost_train_track_pieces_brakes[4] = {
 
 /** rct2: 0x00770BEC */
 static void paint_ghost_train_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -172,7 +172,7 @@ static void paint_ghost_train_track_flat(paint_session * session, uint8 rideInde
 
 /** rct2: 0x00770BFC */
 static void paint_ghost_train_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -224,7 +224,7 @@ static void paint_ghost_train_track_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x00770C0C */
 static void paint_ghost_train_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -275,7 +275,7 @@ static void paint_ghost_train_track_flat_to_25_deg_up(paint_session * session, u
 }
 
 static void paint_ghost_train_track_25_deg_up_to_flat_shared(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -311,9 +311,9 @@ static void paint_ghost_train_track_25_deg_up_to_flat_shared(paint_session * ses
 
 /** rct2: 0x00770C1C */
 static void paint_ghost_train_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_ghost_train_track_25_deg_up_to_flat_shared(session, rideIndex, trackSequence, direction, height, mapElement);
+    paint_ghost_train_track_25_deg_up_to_flat_shared(session, rideIndex, trackSequence, direction, height, tileElement);
 
     switch (direction)
     {
@@ -334,17 +334,17 @@ static void paint_ghost_train_track_25_deg_up_to_flat(paint_session * session, u
 
 /** rct2: 0x00770C2C */
 static void paint_ghost_train_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    paint_ghost_train_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_ghost_train_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x00770C3C */
 static void paint_ghost_train_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     paint_ghost_train_track_25_deg_up_to_flat_shared(session, rideIndex, trackSequence, (direction + 2) % 4, height,
-                                                     mapElement);
+                                                     tileElement);
 
     switch ((direction + 2) % 4)
     {
@@ -365,14 +365,14 @@ static void paint_ghost_train_track_flat_to_25_deg_down(paint_session * session,
 
 /** rct2: 0x00770C4C */
 static void paint_ghost_train_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_ghost_train_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_ghost_train_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x00770C5C, 0x00770C6C, 0x00770C7C */
 static void paint_ghost_train_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -417,7 +417,7 @@ static void paint_ghost_train_station(paint_session * session, uint8 rideIndex,
         metal_a_supports_paint_setup(session, METAL_SUPPORTS_BOXED, 7, 0, height, session->TrackColours[SCHEME_SUPPORTS]);
     }
 
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -425,7 +425,7 @@ static void paint_ghost_train_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x00770C9C */
 static void paint_ghost_train_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_3_tiles_paint(
         session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -461,16 +461,16 @@ static void paint_ghost_train_track_right_quarter_turn_3_tiles(paint_session * s
 
 /** rct2: 0x00770CAC */
 static void paint_ghost_train_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     paint_ghost_train_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x00770CAC */
 static void paint_ghost_train_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_left_quarter_turn_1_tile_paint(session, 3, height, 0, direction, session->TrackColours[SCHEME_TRACK],
                                                     ghost_train_track_pieces_quarter_turn_1_tile, get_current_rotation());
@@ -483,15 +483,15 @@ static void paint_ghost_train_track_left_quarter_turn_1_tile(paint_session * ses
 
 /** rct2: 0x00770CBC */
 static void paint_ghost_train_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     paint_ghost_train_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                     mapElement);
+                                                     tileElement);
 }
 
 /** rct2: 0x00770CCC */
 static void paint_ghost_train_track_spinning_tunnel(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = ghost_train_track_pieces_spinning_tunnel_track[direction] | session->TrackColours[SCHEME_TRACK];
 
@@ -523,7 +523,7 @@ static void paint_ghost_train_track_spinning_tunnel(paint_session * session, uin
 
 /** rct2: 0x00770CDC */
 static void paint_ghost_train_track_brakes(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
diff --git a/src/openrct2/ride/gentle/HauntedHouse.cpp b/src/openrct2/ride/gentle/HauntedHouse.cpp
index 8e3b47c2f8..13709159fc 100644
--- a/src/openrct2/ride/gentle/HauntedHouse.cpp
+++ b/src/openrct2/ride/gentle/HauntedHouse.cpp
@@ -38,7 +38,7 @@ static haunted_house_bound_box haunted_house_data[] = { { 6, 0, 42, 24 }, { 0 },
 static void paint_haunted_house_structure(paint_session * session, uint8 rideIndex, uint8 direction, sint8 xOffset,
                                           sint8 yOffset, uint8 part, uint16 height)
 {
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     uint8 frameNum = 0;
 
@@ -83,7 +83,7 @@ static void paint_haunted_house_structure(paint_session * session, uint8 rideInd
                    boundBox.offset_y, height, get_current_rotation());
     }
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
@@ -91,7 +91,7 @@ static void paint_haunted_house_structure(paint_session * session, uint8 rideInd
  * rct2: 0x0076E9B0
  */
 static void paint_haunted_house(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                rct_tile_element * mapElement)
+                                rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -104,7 +104,7 @@ static void paint_haunted_house(paint_session * session, uint8 rideIndex, uint8
     track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
                                  get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
                                   fenceSpritesRope, get_current_rotation());
 
     switch (trackSequence)
diff --git a/src/openrct2/ride/gentle/Maze.cpp b/src/openrct2/ride/gentle/Maze.cpp
index 16462bbc16..054296bb49 100644
--- a/src/openrct2/ride/gentle/Maze.cpp
+++ b/src/openrct2/ride/gentle/Maze.cpp
@@ -52,9 +52,9 @@ enum
  * rct: 0x004ACF4A
  */
 static void maze_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                             rct_tile_element * mapElement)
+                             rct_tile_element * tileElement)
 {
-    uint16 maze_entry = mapElement->properties.track.maze_entry;
+    uint16 maze_entry = tileElement->properties.track.maze_entry;
     maze_entry        = rol16(maze_entry, direction * 4);
 
     uint32 rotation = get_current_rotation();
diff --git a/src/openrct2/ride/gentle/MerryGoRound.cpp b/src/openrct2/ride/gentle/MerryGoRound.cpp
index e864f14fdd..7d113d04ca 100644
--- a/src/openrct2/ride/gentle/MerryGoRound.cpp
+++ b/src/openrct2/ride/gentle/MerryGoRound.cpp
@@ -32,7 +32,7 @@ static const uint16 merry_go_round_breakdown_vibration[] = { 0, 1, 2, 3, 4, 3, 2
 static void paint_merry_go_round_structure(paint_session * session, uint8 rideIndex, uint8 direction, sint8 xOffset,
                                            sint8 yOffset, uint16 height)
 {
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
     height += 7;
 
     Ride *           ride      = get_ride(rideIndex);
@@ -106,7 +106,7 @@ static void paint_merry_go_round_structure(paint_session * session, uint8 rideIn
         }
     }
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
@@ -114,7 +114,7 @@ static void paint_merry_go_round_structure(paint_session * session, uint8 rideIn
  * rct2: 0x00761B0C
  */
 static void paint_merry_go_round(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -127,7 +127,7 @@ static void paint_merry_go_round(paint_session * session, uint8 rideIndex, uint8
     track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
                                  get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
                                   fenceSpritesRope, get_current_rotation());
 
     switch (trackSequence)
diff --git a/src/openrct2/ride/gentle/MiniGolf.cpp b/src/openrct2/ride/gentle/MiniGolf.cpp
index 8e39166118..2ecba867c7 100644
--- a/src/openrct2/ride/gentle/MiniGolf.cpp
+++ b/src/openrct2/ride/gentle/MiniGolf.cpp
@@ -390,7 +390,7 @@ static paint_struct * mini_golf_paint_util_7c(paint_session * session, uint8 dir
                       z_offset, bound_box_offset_x, bound_box_offset_y, bound_box_offset_z, rotation);
 }
 
-static bool mini_golf_paint_util_should_draw_fence(paint_session * session, rct_tile_element * mapElement)
+static bool mini_golf_paint_util_should_draw_fence(paint_session * session, rct_tile_element * tileElement)
 {
     if (!session->DidPassSurface)
     {
@@ -399,7 +399,7 @@ static bool mini_golf_paint_util_should_draw_fence(paint_session * session, rct_
     }
 
     rct_tile_element * surfaceElement = session->SurfaceElement;
-    if (surfaceElement->base_height != mapElement->base_height)
+    if (surfaceElement->base_height != tileElement->base_height)
     {
         return true;
     }
@@ -414,7 +414,7 @@ static bool mini_golf_paint_util_should_draw_fence(paint_session * session, rct_
 
 /** rct2: 0x0087F10C */
 static void paint_mini_golf_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -435,7 +435,7 @@ static void paint_mini_golf_track_flat(paint_session * session, uint8 rideIndex,
     paint_util_set_segment_support_height(session, paint_util_rotate_segments(SEGMENT_D0 | SEGMENT_C4 | SEGMENT_CC, direction),
                                           0xFFFF, 0);
 
-    if (mini_golf_paint_util_should_draw_fence(session, mapElement))
+    if (mini_golf_paint_util_should_draw_fence(session, tileElement))
     {
         if (direction & 1)
         {
@@ -460,7 +460,7 @@ static void paint_mini_golf_track_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x0087F11C */
 static void paint_mini_golf_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -498,7 +498,7 @@ static void paint_mini_golf_track_25_deg_up(paint_session * session, uint8 rideI
 
 /** rct2: 0x0087F12C */
 static void paint_mini_golf_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -536,7 +536,7 @@ static void paint_mini_golf_track_flat_to_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x0087F13C */
 static void paint_mini_golf_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -574,28 +574,28 @@ static void paint_mini_golf_track_25_deg_up_to_flat(paint_session * session, uin
 
 /** rct2: 0x0087F14C */
 static void paint_mini_golf_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
-    paint_mini_golf_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_mini_golf_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x0087F15C */
 static void paint_mini_golf_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_mini_golf_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_mini_golf_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x0087F16C */
 static void paint_mini_golf_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_mini_golf_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_mini_golf_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x0087F17C, 0x0087F18C, 0x0087F19C */
 static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16                             position      = session->MapPosition;
     Ride *                               ride          = get_ride(rideIndex);
@@ -608,14 +608,14 @@ static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, ui
 
     if (direction & 1)
     {
-        hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
         if (hasFence)
         {
             imageId = SPR_MINI_GOLF_FLAT_FENCE_BACK_NW_SE | session->TrackColours[SCHEME_MISC];
             sub_98197C(session, imageId, -10, 0, 1, 32, 7, height, 0, 0, height + 2, get_current_rotation());
         }
 
-        bool hasSWFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
+        bool hasSWFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
         if (hasFence)
         {
             imageId = SPR_MINI_GOLF_FLAT_FENCE_FRONT_NW_SE | session->TrackColours[SCHEME_MISC];
@@ -630,14 +630,14 @@ static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, ui
     }
     else
     {
-        hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
         if (hasFence)
         {
             imageId = SPR_MINI_GOLF_FLAT_FENCE_BACK_SW_NE | session->TrackColours[SCHEME_MISC];
             sub_98197C(session, imageId, 0, -10, 32, 1, 7, height, 0, 0, height + 2, get_current_rotation());
         }
 
-        bool hasSEFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
+        bool hasSEFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
         if (hasFence)
         {
             imageId = SPR_MINI_GOLF_FLAT_FENCE_FRONT_SW_NE | session->TrackColours[SCHEME_MISC];
@@ -658,7 +658,7 @@ static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x0087F1AC */
 static void paint_mini_golf_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -670,7 +670,7 @@ static void paint_mini_golf_track_left_quarter_turn_1_tile(paint_session * sessi
     paint_util_set_segment_support_height(
         session, paint_util_rotate_segments(SEGMENT_B8 | SEGMENT_C8 | SEGMENT_C4 | SEGMENT_D0, direction), 0xFFFF, 0);
 
-    const bool shouldDrawFence = mini_golf_paint_util_should_draw_fence(session, mapElement);
+    const bool shouldDrawFence = mini_golf_paint_util_should_draw_fence(session, tileElement);
 
     switch (direction)
     {
@@ -737,9 +737,9 @@ static void paint_mini_golf_track_left_quarter_turn_1_tile(paint_session * sessi
 
 /** rct2: 0x0087F1BC */
 static void paint_mini_golf_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_mini_golf_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
+    paint_mini_golf_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 static void paint_mini_golf_hole_ab(paint_session * session, uint8 trackSequence, uint8 direction, sint32 height,
@@ -798,21 +798,21 @@ static void paint_mini_golf_hole_ab(paint_session * session, uint8 trackSequence
 
 /** rct2: 0x0087F1CC */
 static void paint_mini_golf_hole_a(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     paint_mini_golf_hole_ab(session, trackSequence, direction, height, mini_golf_track_sprites_hole_a);
 }
 
 /** rct2: 0x0087F1DC */
 static void paint_mini_golf_hole_b(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     paint_mini_golf_hole_ab(session, trackSequence, direction, height, mini_golf_track_sprites_hole_b);
 }
 
 /** rct2: 0x0087F1EC */
 static void paint_mini_golf_hole_c(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
     LocationXY16 boundBox, boundBoxOffset;
@@ -881,7 +881,7 @@ static void paint_mini_golf_hole_c(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x0087F1FC */
 static void paint_mini_golf_hole_d(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
     LocationXY16 boundBox, boundBoxOffset;
@@ -973,7 +973,7 @@ static void paint_mini_golf_hole_d(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x0087F1FC */
 static void paint_mini_golf_hole_e(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
     LocationXY16 boundBox, boundBoxOffset;
diff --git a/src/openrct2/ride/gentle/MiniHelicopters.cpp b/src/openrct2/ride/gentle/MiniHelicopters.cpp
index 2afc55d77a..e537201126 100644
--- a/src/openrct2/ride/gentle/MiniHelicopters.cpp
+++ b/src/openrct2/ride/gentle/MiniHelicopters.cpp
@@ -25,7 +25,7 @@
 
 /** rct2: 0x */
 static void paint_mini_helicopters_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -54,7 +54,7 @@ static void paint_mini_helicopters_track_station(paint_session * session, uint8
         paint_util_push_tunnel_right(session, height, TUNNEL_6);
     }
 
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -62,7 +62,7 @@ static void paint_mini_helicopters_track_station(paint_session * session, uint8
 
 /** rct2: 0x0081F348 */
 static void paint_mini_helicopters_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
     uint32   imageId;
@@ -93,7 +93,7 @@ static void paint_mini_helicopters_track_flat(paint_session * session, uint8 rid
 
 /** rct2: 0x0081F368 */
 static void paint_mini_helicopters_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
     uint32   imageId;
@@ -134,7 +134,7 @@ static void paint_mini_helicopters_track_flat_to_25_deg_up(paint_session * sessi
 
 /** rct2: 0x0081F358 */
 static void paint_mini_helicopters_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
     uint32   imageId;
@@ -175,7 +175,7 @@ static void paint_mini_helicopters_track_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x0081F378 */
 static void paint_mini_helicopters_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
     uint32   imageId;
@@ -216,29 +216,29 @@ static void paint_mini_helicopters_track_25_deg_up_to_flat(paint_session * sessi
 
 /** rct2: 0x */
 static void paint_mini_helicopters_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_mini_helicopters_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_mini_helicopters_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x0081F388 */
 static void paint_mini_helicopters_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_mini_helicopters_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_mini_helicopters_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x0081F3A8 */
 static void paint_mini_helicopters_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_mini_helicopters_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_mini_helicopters_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x0081F3E8 */
 static void paint_mini_helicopters_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     track_paint_util_left_quarter_turn_3_tiles_paint(
         session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -271,16 +271,16 @@ static const uint8 mini_helicopters_right_quarter_turn_3_tiles_to_left_turn_map[
 /** rct2: 0x0081F3F8 */
 static void paint_mini_helicopters_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mini_helicopters_right_quarter_turn_3_tiles_to_left_turn_map[trackSequence];
     paint_mini_helicopters_track_left_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                           mapElement);
+                                                           tileElement);
 }
 
 /** rct2: 0x0081F408 */
 static void paint_mini_helicopters_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_left_quarter_turn_1_tile_paint(session, 1, height, 0, direction, session->TrackColours[SCHEME_TRACK],
                                                     trackSpritesSubmarineRideMiniHelicoptersQuarterTurn1Tile,
@@ -295,10 +295,10 @@ static void paint_mini_helicopters_track_left_quarter_turn_1_tile(paint_session
 /** rct2: 0x0081F418 */
 static void paint_mini_helicopters_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     paint_mini_helicopters_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 /**
diff --git a/src/openrct2/ride/gentle/MonorailCycles.cpp b/src/openrct2/ride/gentle/MonorailCycles.cpp
index e84fa4139e..df0c806585 100644
--- a/src/openrct2/ride/gentle/MonorailCycles.cpp
+++ b/src/openrct2/ride/gentle/MonorailCycles.cpp
@@ -164,7 +164,7 @@ static paint_struct * paint_monorail_cycles_util_7c(paint_session * session, boo
 
 /** rct2: 0x0088AD48 */
 static void paint_monorail_cycles_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = monorail_cycles_track_pieces_flat[(direction & 1)] | session->TrackColours[SCHEME_TRACK];
     paint_monorail_cycles_util_7c(session, (bool)(direction & 1), imageId, 0, 0, 32, 20, 3, height, 0, 6, height,
@@ -189,7 +189,7 @@ static void paint_monorail_cycles_track_flat(paint_session * session, uint8 ride
 
 /** rct2: 0x0088ADD8 */
 static void paint_monorail_cycles_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -218,7 +218,7 @@ static void paint_monorail_cycles_station(paint_session * session, uint8 rideInd
         paint_util_push_tunnel_right(session, height, TUNNEL_6);
     }
 
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -226,7 +226,7 @@ static void paint_monorail_cycles_station(paint_session * session, uint8 rideInd
 
 /** rct2: 0x0088AD88 */
 static void paint_monorail_cycles_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_left_quarter_turn_3_tiles_paint(
         session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -259,11 +259,11 @@ static const uint8 monorail_cycles_right_quarter_turn_3_tiles_to_left_turn_map[]
 /** rct2: 0x0088AD98 */
 static void paint_monorail_cycles_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     trackSequence = monorail_cycles_right_quarter_turn_3_tiles_to_left_turn_map[trackSequence];
     paint_monorail_cycles_track_left_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 static const sint8 monorail_cycles_track_right_quarter_turn_5_tiles_support_height_offset[][7] = {
@@ -283,7 +283,7 @@ static const sint8 monorail_cycles_track_right_quarter_turn_5_tiles_support_spec
 /** rct2: 0x0088ADB8 */
 static void paint_monorail_cycles_track_right_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex,
                                                                    uint8 trackSequence, uint8 direction, sint32 height,
-                                                                   rct_tile_element * mapElement)
+                                                                   rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_5_tiles_paint(
         session, 1, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -386,16 +386,16 @@ static void paint_monorail_cycles_track_right_quarter_turn_5_tiles(paint_session
 
 /** rct2: 0x0088ADA8 */
 static void paint_monorail_cycles_track_left_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     paint_monorail_cycles_track_right_quarter_turn_5_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                           mapElement);
+                                                           tileElement);
 }
 
 /** rct2: 0x0088ADC8 */
 static void paint_monorail_cycles_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
@@ -498,7 +498,7 @@ static void paint_monorail_cycles_track_s_bend_left(paint_session * session, uin
 
 /** rct2: 0x*/
 static void paint_monorail_cycles_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
diff --git a/src/openrct2/ride/gentle/ObservationTower.cpp b/src/openrct2/ride/gentle/ObservationTower.cpp
index 258c329e49..cf9535f22d 100644
--- a/src/openrct2/ride/gentle/ObservationTower.cpp
+++ b/src/openrct2/ride/gentle/ObservationTower.cpp
@@ -81,7 +81,7 @@ void vehicle_visual_observation_tower(paint_session * session, sint32 x, sint32
 
 /** rct2: 0x0070DD6C */
 static void paint_observation_tower_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -94,7 +94,7 @@ static void paint_observation_tower_base(paint_session * session, uint8 rideInde
     uint32 imageId = SPR_FLOOR_METAL_B | session->TrackColours[SCHEME_SUPPORTS];
     sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
                                   fenceSpritesMetalB, get_current_rotation());
 
     if (trackSequence == 0)
@@ -157,7 +157,7 @@ static void paint_observation_tower_base(paint_session * session, uint8 rideInde
 
 /** rct2: 0x0070DD7C */
 static void paint_observation_tower_section(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence == 1)
     {
@@ -167,8 +167,8 @@ static void paint_observation_tower_section(paint_session * session, uint8 rideI
     uint32 imageId = SPR_OBSERVATION_TOWER_SEGMENT | session->TrackColours[SCHEME_TRACK];
     sub_98197C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
 
-    rct_tile_element * nextMapElement = mapElement + 1;
-    if (tile_element_is_last_for_tile(mapElement) || mapElement->clearance_height != nextMapElement->base_height)
+    rct_tile_element * nextTileElement = tileElement + 1;
+    if (tile_element_is_last_for_tile(tileElement) || tileElement->clearance_height != nextTileElement->base_height)
     {
         imageId = SPR_OBSERVATION_TOWER_SEGMENT_TOP | session->TrackColours[SCHEME_TRACK];
         sub_98199C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
diff --git a/src/openrct2/ride/gentle/SpaceRings.cpp b/src/openrct2/ride/gentle/SpaceRings.cpp
index 0bfc77837e..a2c94c69e7 100644
--- a/src/openrct2/ride/gentle/SpaceRings.cpp
+++ b/src/openrct2/ride/gentle/SpaceRings.cpp
@@ -39,7 +39,7 @@ static const uint32 space_rings_fence_sprites[] = {
 /** rct2: 0x00768A3B */
 static void paint_space_rings_structure(paint_session * session, Ride * ride, uint8 direction, uint32 segment, sint32 height)
 {
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     uint32 vehicleIndex = (segment - direction) & 0x3;
 
@@ -84,13 +84,13 @@ static void paint_space_rings_structure(paint_session * session, Ride * ride, ui
         }
     }
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
 /** rct2: 0x00767C40 */
 static void paint_space_rings(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                              rct_tile_element * mapElement)
+                              rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -108,19 +108,19 @@ static void paint_space_rings(paint_session * session, uint8 rideIndex, uint8 tr
     switch (trackSequence)
     {
     case 7:
-        if (track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation()))
+        if (track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation()))
         {
             imageId = SPR_SPACE_RINGS_FENCE_SW | session->TrackColours[SCHEME_MISC];
             sub_98197C(session, imageId, 0, 0, 1, 28, 7, height, 29, 0, height + 2, get_current_rotation());
         }
-        if (track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation()))
+        if (track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation()))
         {
             imageId = SPR_SPACE_RINGS_FENCE_SE | session->TrackColours[SCHEME_MISC];
             sub_98197C(session, imageId, 0, 0, 28, 1, 7, height, 0, 29, height + 2, get_current_rotation());
         }
         break;
     default:
-        track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
+        track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
                                       space_rings_fence_sprites, get_current_rotation());
         break;
     }
diff --git a/src/openrct2/ride/gentle/SpiralSlide.cpp b/src/openrct2/ride/gentle/SpiralSlide.cpp
index 23d99cda19..968751316c 100644
--- a/src/openrct2/ride/gentle/SpiralSlide.cpp
+++ b/src/openrct2/ride/gentle/SpiralSlide.cpp
@@ -53,7 +53,7 @@ enum
 };
 
 static void spiral_slide_paint_tile_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id = 0;
 
@@ -70,7 +70,7 @@ static void spiral_slide_paint_tile_right(paint_session * session, uint8 rideInd
 }
 
 static void spiral_slide_paint_tile_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id = 0;
 
@@ -87,7 +87,7 @@ static void spiral_slide_paint_tile_left(paint_session * session, uint8 rideInde
 }
 
 static void spiral_slide_paint_tile_front(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     uint32 image_id = 0;
 
@@ -194,7 +194,7 @@ static const uint32 spiral_slide_fence_sprites[] = {
  * rct: 0x007485C8
  */
 static void paint_spiral_slide(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                               rct_tile_element * mapElement)
+                               rct_tile_element * tileElement)
 {
     trackSequence = track_map_2x2[direction][trackSequence];
 
@@ -208,19 +208,19 @@ static void paint_spiral_slide(paint_session * session, uint8 rideIndex, uint8 t
     uint32 imageId = ((direction & 1) ? SPIRAL_SLIDE_BASE_B : SPIRAL_SLIDE_BASE_A) | session->TrackColours[SCHEME_SUPPORTS];
     sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
                                   spiral_slide_fence_sprites, get_current_rotation());
 
     switch (trackSequence)
     {
     case 1:
-        spiral_slide_paint_tile_right(session, rideIndex, trackSequence, direction, height, mapElement);
+        spiral_slide_paint_tile_right(session, rideIndex, trackSequence, direction, height, tileElement);
         break;
     case 2:
-        spiral_slide_paint_tile_left(session, rideIndex, trackSequence, direction, height, mapElement);
+        spiral_slide_paint_tile_left(session, rideIndex, trackSequence, direction, height, tileElement);
         break;
     case 3:
-        spiral_slide_paint_tile_front(session, rideIndex, trackSequence, direction, height, mapElement);
+        spiral_slide_paint_tile_front(session, rideIndex, trackSequence, direction, height, tileElement);
         break;
     }
 
diff --git a/src/openrct2/ride/ride.c b/src/openrct2/ride/ride.c
index 4e5440478e..e71762b9bc 100644
--- a/src/openrct2/ride/ride.c
+++ b/src/openrct2/ride/ride.c
@@ -214,7 +214,7 @@ static void ride_shop_connected(Ride* ride, sint32 ride_idx);
 static void ride_spiral_slide_update(Ride *ride);
 static void ride_update(sint32 rideIndex);
 static void ride_update_vehicle_colours(sint32 rideIndex);
-void loc_6DDF9C(Ride *ride, rct_tile_element *mapElement);
+void loc_6DDF9C(Ride *ride, rct_tile_element *tileElement);
 
 Ride *get_ride(sint32 index)
 {
@@ -480,7 +480,7 @@ static money32 ride_calculate_income_per_hour(Ride *ride)
  */
 bool ride_try_get_origin_element(sint32 rideIndex, rct_xy_element *output)
 {
-    rct_tile_element *resultMapElement = NULL;
+    rct_tile_element *resultTileElement = NULL;
 
     tile_element_iterator it;
     tile_element_iterator_begin(&it);
@@ -500,11 +500,11 @@ bool ride_try_get_origin_element(sint32 rideIndex, rct_xy_element *output)
         );
 
         // Set result tile to this track piece if first found track or a ???
-        if (resultMapElement == NULL || specialTrackPiece) {
-            resultMapElement = it.element;
+        if (resultTileElement == NULL || specialTrackPiece) {
+            resultTileElement = it.element;
 
             if (output != NULL) {
-                output->element = resultMapElement;
+                output->element = resultTileElement;
                 output->x = it.x * 32;
                 output->y = it.y * 32;
             }
@@ -515,7 +515,7 @@ bool ride_try_get_origin_element(sint32 rideIndex, rct_xy_element *output)
         }
     } while (tile_element_iterator_next(&it));
 
-    return resultMapElement != NULL;
+    return resultTileElement != NULL;
 }
 
 /**
@@ -535,50 +535,50 @@ bool track_block_get_next_from_zero(sint16 x, sint16 y, sint16 z_start, uint8 ri
         y += TileDirectionDelta[direction_start].y;
     }
 
-    rct_tile_element* mapElement = map_get_first_element_at(x / 32, y / 32);
-    if (mapElement == NULL){
+    rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
+    if (tileElement == NULL){
         output->element = NULL;
         output->x = LOCATION_NULL;
         return 0;
     }
 
     do{
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if (mapElement->properties.track.ride_index != rideIndex)
+        if (tileElement->properties.track.ride_index != rideIndex)
             continue;
 
-        if (tile_element_get_track_sequence(mapElement) != 0)
+        if (tile_element_get_track_sequence(tileElement) != 0)
             continue;
 
-        const rct_preview_track* nextTrackBlock = get_track_def_from_ride(ride, mapElement->properties.track.type);
-        const rct_track_coordinates* nextTrackCoordinate = get_track_coord_from_ride(ride, mapElement->properties.track.type);
+        const rct_preview_track* nextTrackBlock = get_track_def_from_ride(ride, tileElement->properties.track.type);
+        const rct_track_coordinates* nextTrackCoordinate = get_track_coord_from_ride(ride, tileElement->properties.track.type);
 
         uint8 nextRotation =
-            tile_element_get_direction_with_offset(mapElement, nextTrackCoordinate->rotation_begin) |
+            tile_element_get_direction_with_offset(tileElement, nextTrackCoordinate->rotation_begin) |
             (nextTrackCoordinate->rotation_begin & (1 << 2));
 
         if (nextRotation != direction_start)
             continue;
 
-        sint16 nextZ = nextTrackCoordinate->z_begin - nextTrackBlock->z + mapElement->base_height * 8;
+        sint16 nextZ = nextTrackCoordinate->z_begin - nextTrackBlock->z + tileElement->base_height * 8;
         if (nextZ != z_start)
             continue;
 
-        if (z != NULL) *z = mapElement->base_height * 8;
+        if (z != NULL) *z = tileElement->base_height * 8;
         if (direction != NULL) *direction = nextRotation;
         output->x = x;
         output->y = y;
-        output->element = mapElement;
+        output->element = tileElement;
         return 1;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     if (direction != NULL) *direction = direction_start;
     if (z != NULL) *z = z_start;
     output->x = x;
     output->y = y;
-    output->element = --mapElement;
+    output->element = --tileElement;
     return 0;
 }
 
@@ -657,8 +657,8 @@ bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 ride
         y += TileDirectionDelta[direction].y;
     }
 
-    rct_tile_element* mapElement = map_get_first_element_at(x / 32, y / 32);
-    if (mapElement == NULL){
+    rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
+    if (tileElement == NULL){
         outTrackBeginEnd->end_x = x;
         outTrackBeginEnd->end_y = y;
         outTrackBeginEnd->begin_element = NULL;
@@ -667,34 +667,34 @@ bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 ride
     }
 
     do{
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if (mapElement->properties.track.ride_index != rideIndex)
+        if (tileElement->properties.track.ride_index != rideIndex)
             continue;
 
-        const rct_preview_track* nextTrackBlock = get_track_def_from_ride(ride, mapElement->properties.track.type);
-        const rct_track_coordinates* nextTrackCoordinate = get_track_coord_from_ride(ride, mapElement->properties.track.type);
+        const rct_preview_track* nextTrackBlock = get_track_def_from_ride(ride, tileElement->properties.track.type);
+        const rct_track_coordinates* nextTrackCoordinate = get_track_coord_from_ride(ride, tileElement->properties.track.type);
 
-        nextTrackBlock += tile_element_get_track_sequence(mapElement);
+        nextTrackBlock += tile_element_get_track_sequence(tileElement);
         if ((nextTrackBlock + 1)->index != 255)
             continue;
 
         uint8 nextRotation =
-            tile_element_get_direction_with_offset(mapElement, nextTrackCoordinate->rotation_end) |
+            tile_element_get_direction_with_offset(tileElement, nextTrackCoordinate->rotation_end) |
             (nextTrackCoordinate->rotation_end & (1 << 2));
 
         if (nextRotation != directionStart)
             continue;
 
-        sint16 nextZ = nextTrackCoordinate->z_end - nextTrackBlock->z + mapElement->base_height * 8;
+        sint16 nextZ = nextTrackCoordinate->z_end - nextTrackBlock->z + tileElement->base_height * 8;
         if (nextZ != z)
             continue;
 
         nextRotation =
-            tile_element_get_direction_with_offset(mapElement, nextTrackCoordinate->rotation_begin) |
+            tile_element_get_direction_with_offset(tileElement, nextTrackCoordinate->rotation_begin) |
             (nextTrackCoordinate->rotation_begin & (1 << 2));
-        outTrackBeginEnd->begin_element = mapElement;
+        outTrackBeginEnd->begin_element = tileElement;
         outTrackBeginEnd->begin_x = x;
         outTrackBeginEnd->begin_y = y;
         outTrackBeginEnd->end_x = x;
@@ -718,15 +718,15 @@ bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 ride
             break;
         }
 
-        outTrackBeginEnd->begin_z = mapElement->base_height * 8;
+        outTrackBeginEnd->begin_z = tileElement->base_height * 8;
         outTrackBeginEnd->begin_z +=
-            get_track_def_from_ride(ride, mapElement->properties.track.type)->z -
+            get_track_def_from_ride(ride, tileElement->properties.track.type)->z -
             nextTrackBlock->z;
 
         outTrackBeginEnd->begin_direction = nextRotation;
         outTrackBeginEnd->end_direction = directionStart ^ (1 << 1);
         return 1;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     outTrackBeginEnd->end_x = x;
     outTrackBeginEnd->end_y = y;
@@ -744,20 +744,20 @@ bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 ride
  * higher two bytes of ecx and edx where as outTrackBeginEnd.end_x and
  * outTrackBeginEnd.end_y will be in the lower two bytes (cx and dx).
  */
-bool track_block_get_previous(sint32 x, sint32 y, rct_tile_element *mapElement, track_begin_end *outTrackBeginEnd)
+bool track_block_get_previous(sint32 x, sint32 y, rct_tile_element *tileElement, track_begin_end *outTrackBeginEnd)
 {
-    uint8 rideIndex = mapElement->properties.track.ride_index;
+    uint8 rideIndex = tileElement->properties.track.ride_index;
     Ride* ride = get_ride(rideIndex);
 
-    const rct_preview_track* trackBlock = get_track_def_from_ride(ride, mapElement->properties.track.type);
-    uint8 sequence = tile_element_get_track_sequence(mapElement);
+    const rct_preview_track* trackBlock = get_track_def_from_ride(ride, tileElement->properties.track.type);
+    uint8 sequence = tile_element_get_track_sequence(tileElement);
     trackBlock += sequence;
 
-    const rct_track_coordinates* trackCoordinate = get_track_coord_from_ride(ride, mapElement->properties.track.type);
+    const rct_track_coordinates* trackCoordinate = get_track_coord_from_ride(ride, tileElement->properties.track.type);
 
-    sint32 z = mapElement->base_height * 8;
+    sint32 z = tileElement->base_height * 8;
 
-    uint8 rotation = tile_element_get_direction(mapElement);
+    uint8 rotation = tile_element_get_direction(tileElement);
     switch (rotation){
     case 0:
         x -= trackBlock->x;
@@ -1131,9 +1131,9 @@ void ride_remove_peeps(sint32 rideIndex)
             exitX = location.x;
             exitY = location.y;
             exitZ = ride->station_heights[stationIndex];
-            rct_tile_element *mapElement = ride_get_station_exit_element(ride, exitX, exitY, exitZ);
+            rct_tile_element *tileElement = ride_get_station_exit_element(ride, exitX, exitY, exitZ);
 
-            exitDirection = (mapElement == NULL ? 0 : tile_element_get_direction(mapElement));
+            exitDirection = (tileElement == NULL ? 0 : tile_element_get_direction(tileElement));
             exitX = (exitX * 32) - (word_981D6C[exitDirection].x * 20) + 16;
             exitY = (exitY * 32) - (word_981D6C[exitDirection].y * 20) + 16;
             exitZ = (exitZ * 8) + 2;
@@ -1205,36 +1205,36 @@ void ride_remove_peeps(sint32 rideIndex)
  */
 sint32 sub_6C683D(sint32* x, sint32* y, sint32* z, sint32 direction, sint32 type, uint16 extra_params, rct_tile_element** output_element, uint16 flags)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(*x / 32, *y / 32);
-    rct_tile_element *successMapElement = NULL;
+    rct_tile_element *tileElement = map_get_first_element_at(*x / 32, *y / 32);
+    rct_tile_element *successTileElement = NULL;
 
     do {
-        if (mapElement->base_height != *z / 8)
+        if (tileElement->base_height != *z / 8)
             continue;
 
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if ((tile_element_get_direction(mapElement)) != direction)
+        if ((tile_element_get_direction(tileElement)) != direction)
             continue;
 
-        if (type != mapElement->properties.track.type)
+        if (type != tileElement->properties.track.type)
             continue;
 
-        successMapElement = mapElement;
-        if (tile_element_get_track_sequence(mapElement) == 0)
+        successTileElement = tileElement;
+        if (tile_element_get_track_sequence(tileElement) == 0)
             break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
-    mapElement = successMapElement;
-    if (mapElement == NULL)
+    tileElement = successTileElement;
+    if (tileElement == NULL)
         return 1;
 
     // Possibly z should be & 0xF8
-    const rct_preview_track *trackBlock = get_track_def_from_ride_index(mapElement->properties.track.ride_index, type);
+    const rct_preview_track *trackBlock = get_track_def_from_ride_index(tileElement->properties.track.ride_index, type);
 
-    sint32 sequence = tile_element_get_track_sequence(mapElement);
-    uint8 mapDirection = tile_element_get_direction(mapElement);
+    sint32 sequence = tile_element_get_track_sequence(tileElement);
+    uint8 mapDirection = tile_element_get_direction(tileElement);
 
     switch (mapDirection){
     case TILE_ELEMENT_DIRECTION_WEST:
@@ -1282,59 +1282,59 @@ sint32 sub_6C683D(sint32* x, sint32* y, sint32* z, sint32 direction, sint32 type
 
         map_invalidate_tile_full(cur_x, cur_y);
 
-        mapElement = map_get_first_element_at(cur_x / 32, cur_y / 32);
-        successMapElement = NULL;
+        tileElement = map_get_first_element_at(cur_x / 32, cur_y / 32);
+        successTileElement = NULL;
         do {
-            if (mapElement->base_height != cur_z / 8)
+            if (tileElement->base_height != cur_z / 8)
                 continue;
 
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                 continue;
 
-            if ((tile_element_get_direction(mapElement)) != direction)
+            if ((tile_element_get_direction(tileElement)) != direction)
                 continue;
 
-            if (tile_element_get_track_sequence(mapElement) != trackBlock[i].index)
+            if (tile_element_get_track_sequence(tileElement) != trackBlock[i].index)
                 continue;
 
-            if (type == mapElement->properties.track.type) {
-                successMapElement = mapElement;
+            if (type == tileElement->properties.track.type) {
+                successTileElement = tileElement;
                 break;
             }
         }
-        while (!tile_element_is_last_for_tile(mapElement++));
+        while (!tile_element_is_last_for_tile(tileElement++));
 
-        if (successMapElement == NULL)
+        if (successTileElement == NULL)
         {
             return 1;
         }
         if (i == 0 && output_element != NULL)
         {
-            *output_element = mapElement;
+            *output_element = tileElement;
         }
         if (flags & (1 << 0))
         {
-            mapElement->type &= ~TILE_ELEMENT_TYPE_FLAG_HIGHLIGHT;
+            tileElement->type &= ~TILE_ELEMENT_TYPE_FLAG_HIGHLIGHT;
         }
         if (flags & (1 << 1))
         {
-            mapElement->type |= TILE_ELEMENT_TYPE_FLAG_HIGHLIGHT;
+            tileElement->type |= TILE_ELEMENT_TYPE_FLAG_HIGHLIGHT;
         }
         if (flags & (1 << 2))
         {
-            track_element_set_colour_scheme(mapElement, (uint8)(extra_params & 0xFF));
+            track_element_set_colour_scheme(tileElement, (uint8)(extra_params & 0xFF));
         }
         if (flags & (1 << 5))
         {
-            track_element_set_seat_rotation(mapElement, (uint8)(extra_params & 0xFF));
+            track_element_set_seat_rotation(tileElement, (uint8)(extra_params & 0xFF));
         }
 
         if (flags & (1 << 3)) {
-            track_element_set_cable_lift(mapElement);
+            track_element_set_cable_lift(tileElement);
         }
         if (flags & (1 << 4))
         {
-            track_element_clear_cable_lift(mapElement);
+            track_element_clear_cable_lift(tileElement);
         }
     }
 
@@ -1494,7 +1494,7 @@ void ride_construction_set_default_next_piece()
     Ride *ride;
     track_begin_end trackBeginEnd;
     rct_xy_element xyElement;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     _currentTrackPrice = MONEY32_UNDEFINED;
     switch (_rideConstructionState) {
@@ -1510,8 +1510,8 @@ void ride_construction_set_default_next_piece()
             ride_construction_reset_current_piece();
             return;
         }
-        mapElement = trackBeginEnd.begin_element;
-        trackType = mapElement->properties.track.type;
+        tileElement = trackBeginEnd.begin_element;
+        trackType = tileElement->properties.track.type;
 
         if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_NO_TRACK)) {
             ride_construction_reset_current_piece();
@@ -1522,7 +1522,7 @@ void ride_construction_set_default_next_piece()
         _currentTrackAlternative &= ~RIDE_TYPE_ALTERNATIVE_TRACK_TYPE;
         if (RideData4[ride->type].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
         {
-            if (track_element_is_inverted(mapElement))
+            if (track_element_is_inverted(tileElement))
             {
                 _currentTrackAlternative |= RIDE_TYPE_ALTERNATIVE_TRACK_TYPE;
             }
@@ -1558,7 +1558,7 @@ void ride_construction_set_default_next_piece()
         // Set track slope and lift hill
         _currentTrackSlopeEnd = slope;
         _previousTrackSlopeEnd = slope;
-        _currentTrackLiftHill = ((mapElement->type & 0x80) && slope != TRACK_SLOPE_DOWN_25 && slope != TRACK_SLOPE_DOWN_60) != 0;
+        _currentTrackLiftHill = ((tileElement->type & 0x80) && slope != TRACK_SLOPE_DOWN_25 && slope != TRACK_SLOPE_DOWN_60) != 0;
         break;
     case RIDE_CONSTRUCTION_STATE_BACK:
         rideIndex = _currentRideIndex;
@@ -1572,14 +1572,14 @@ void ride_construction_set_default_next_piece()
             ride_construction_reset_current_piece();
             return;
         }
-        mapElement = xyElement.element;
-        trackType = mapElement->properties.track.type;
+        tileElement = xyElement.element;
+        trackType = tileElement->properties.track.type;
 
         // Set whether track is covered
         _currentTrackAlternative &= ~RIDE_TYPE_ALTERNATIVE_TRACK_TYPE;
         if (RideData4[ride->type].flags & RIDE_TYPE_FLAG4_HAS_ALTERNATIVE_TRACK_TYPE)
         {
-            if (track_element_is_inverted(mapElement))
+            if (track_element_is_inverted(tileElement))
             {
                 _currentTrackAlternative |= RIDE_TYPE_ALTERNATIVE_TRACK_TYPE;
             }
@@ -1619,7 +1619,7 @@ void ride_construction_set_default_next_piece()
         _currentTrackSlopeEnd = slope;
         _previousTrackSlopeEnd = slope;
         if (!gCheatsEnableChainLiftOnAllTrack) {
-            _currentTrackLiftHill = track_element_is_lift_hill(mapElement);
+            _currentTrackLiftHill = track_element_is_lift_hill(tileElement);
         }
         break;
     }
@@ -1638,8 +1638,8 @@ void ride_select_next_section()
         sint32 z = _currentTrackBeginZ;
         sint32 direction = _currentTrackPieceDirection;
         sint32 type = _currentTrackPieceType;
-        rct_tile_element *mapElement;
-        if (sub_6C683D(&x, &y, &z, direction & 3, type, 0, &mapElement, 0)) {
+        rct_tile_element *tileElement;
+        if (sub_6C683D(&x, &y, &z, direction & 3, type, 0, &tileElement, 0)) {
             _rideConstructionState = RIDE_CONSTRUCTION_STATE_0;
             window_ride_construction_update_active_elements();
             return;
@@ -1647,18 +1647,18 @@ void ride_select_next_section()
         rct_xy_element inputElement, outputElement;
         inputElement.x = x;
         inputElement.y = y;
-        inputElement.element = mapElement;
+        inputElement.element = tileElement;
         if (track_block_get_next(&inputElement, &outputElement, &z, &direction)) {
             x = outputElement.x;
             y = outputElement.y;
-            mapElement = outputElement.element;
+            tileElement = outputElement.element;
         } else {
             _rideConstructionState = RIDE_CONSTRUCTION_STATE_FRONT;
             _currentTrackBeginX = outputElement.x;
             _currentTrackBeginY = outputElement.y;
             _currentTrackBeginZ = z;
             _currentTrackPieceDirection = direction;
-            _currentTrackPieceType = mapElement->properties.track.type;
+            _currentTrackPieceType = tileElement->properties.track.type;
             _currentTrackSelectionFlags = 0;
             _rideConstructionArrowPulseTime = 0;
             ride_construction_set_default_next_piece();
@@ -1669,8 +1669,8 @@ void ride_select_next_section()
         _currentTrackBeginX = x;
         _currentTrackBeginY = y;
         _currentTrackBeginZ = z;
-        _currentTrackPieceDirection = tile_element_get_direction(mapElement);
-        _currentTrackPieceType = mapElement->properties.track.type;
+        _currentTrackPieceDirection = tile_element_get_direction(tileElement);
+        _currentTrackPieceType = tileElement->properties.track.type;
         _currentTrackSelectionFlags = 0;
         _rideConstructionArrowPulseTime = 0;
         window_ride_construction_update_active_elements();
@@ -1694,14 +1694,14 @@ void ride_select_previous_section()
         sint32 z = _currentTrackBeginZ;
         sint32 direction = _currentTrackPieceDirection;
         sint32 type = _currentTrackPieceType;
-        rct_tile_element *mapElement;
-        if (sub_6C683D(&x, &y, &z, direction & 3, type, 0, &mapElement, 0)) {
+        rct_tile_element *tileElement;
+        if (sub_6C683D(&x, &y, &z, direction & 3, type, 0, &tileElement, 0)) {
             _rideConstructionState = RIDE_CONSTRUCTION_STATE_0;
             window_ride_construction_update_active_elements();
             return;
         }
         track_begin_end trackBeginEnd;
-        if (track_block_get_previous(x, y, mapElement, &trackBeginEnd)) {
+        if (track_block_get_previous(x, y, tileElement, &trackBeginEnd)) {
             _currentTrackBeginX = trackBeginEnd.begin_x;
             _currentTrackBeginY = trackBeginEnd.begin_y;
             _currentTrackBeginZ = trackBeginEnd.begin_z;
@@ -1716,7 +1716,7 @@ void ride_select_previous_section()
             _currentTrackBeginY = trackBeginEnd.end_y;
             _currentTrackBeginZ = trackBeginEnd.begin_z;
             _currentTrackPieceDirection = trackBeginEnd.end_direction;
-            _currentTrackPieceType = mapElement->properties.track.type;
+            _currentTrackPieceType = tileElement->properties.track.type;
             _currentTrackSelectionFlags = 0;
             _rideConstructionArrowPulseTime = 0;
             ride_construction_set_default_next_piece();
@@ -1733,18 +1733,18 @@ void ride_select_previous_section()
  *
  *  rct2: 0x006CC2CA
  */
-static sint32 ride_modify_entrance_or_exit(rct_tile_element *mapElement, sint32 x, sint32 y)
+static sint32 ride_modify_entrance_or_exit(rct_tile_element *tileElement, sint32 x, sint32 y)
 {
     sint32 rideIndex, entranceType;
     rct_window *constructionWindow;
 
-    rideIndex = mapElement->properties.entrance.ride_index;
+    rideIndex = tileElement->properties.entrance.ride_index;
 
-    entranceType = mapElement->properties.entrance.type;
+    entranceType = tileElement->properties.entrance.type;
     if (entranceType != ENTRANCE_TYPE_RIDE_ENTRANCE && entranceType != ENTRANCE_TYPE_RIDE_EXIT)
         return 0;
 
-    sint32 bl = (mapElement->properties.entrance.index & 0x70) >> 4;
+    sint32 bl = (tileElement->properties.entrance.index & 0x70) >> 4;
 
     // Get or create construction window for ride
     constructionWindow = window_find_by_class(WC_RIDE_CONSTRUCTION);
@@ -1791,13 +1791,13 @@ static sint32 ride_modify_entrance_or_exit(rct_tile_element *mapElement, sint32
  *
  *  rct2: 0x006CC287
  */
-static sint32 ride_modify_maze(rct_tile_element *mapElement, sint32 x, sint32 y)
+static sint32 ride_modify_maze(rct_tile_element *tileElement, sint32 x, sint32 y)
 {
-    _currentRideIndex = mapElement->properties.track.ride_index;
+    _currentRideIndex = tileElement->properties.track.ride_index;
     _rideConstructionState = RIDE_CONSTRUCTION_STATE_MAZE_BUILD;
     _currentTrackBeginX = x;
     _currentTrackBeginY = y;
-    _currentTrackBeginZ = mapElement->base_height * 8;
+    _currentTrackBeginZ = tileElement->base_height * 8;
     _currentTrackSelectionFlags = 0;
     _rideConstructionArrowPulseTime = 0;
     window_maze_construction_update_pressed_widgets();
@@ -1811,12 +1811,12 @@ static sint32 ride_modify_maze(rct_tile_element *mapElement, sint32 x, sint32 y)
 sint32 ride_modify(rct_xy_element *input)
 {
     sint32 rideIndex, x, y, z, direction, type;
-    rct_xy_element mapElement, endOfTrackElement;
+    rct_xy_element tileElement, endOfTrackElement;
     Ride *ride;
     rct_ride_entry *rideEntry;
 
-    mapElement = *input;
-    rideIndex = mapElement.element->properties.track.ride_index;
+    tileElement = *input;
+    rideIndex = tileElement.element->properties.track.ride_index;
     ride = get_ride(rideIndex);
     if (ride == NULL) {
         return 0;
@@ -1837,24 +1837,24 @@ sint32 ride_modify(rct_xy_element *input)
     ride_set_status(rideIndex, RIDE_STATUS_CLOSED);
 
     // Check if element is a station entrance or exit
-    if (tile_element_get_type(mapElement.element) == TILE_ELEMENT_TYPE_ENTRANCE)
-        return ride_modify_entrance_or_exit(mapElement.element, mapElement.x, mapElement.y);
+    if (tile_element_get_type(tileElement.element) == TILE_ELEMENT_TYPE_ENTRANCE)
+        return ride_modify_entrance_or_exit(tileElement.element, tileElement.x, tileElement.y);
 
     ride_create_or_find_construction_window(rideIndex);
 
     if (ride->type == RIDE_TYPE_MAZE)
-        return ride_modify_maze(mapElement.element, mapElement.x, mapElement.y);
+        return ride_modify_maze(tileElement.element, tileElement.x, tileElement.y);
 
     if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_CANNOT_HAVE_GAPS)) {
-        if (ride_find_track_gap(&mapElement, &endOfTrackElement))
-            mapElement = endOfTrackElement;
+        if (ride_find_track_gap(&tileElement, &endOfTrackElement))
+            tileElement = endOfTrackElement;
     }
 
-    x = mapElement.x;
-    y = mapElement.y;
-    z = mapElement.element->base_height * 8;
-    direction = tile_element_get_direction(mapElement.element);
-    type = mapElement.element->properties.track.type;
+    x = tileElement.x;
+    y = tileElement.y;
+    z = tileElement.element->base_height * 8;
+    direction = tile_element_get_direction(tileElement.element);
+    type = tileElement.element->properties.track.type;
 
     if (sub_6C683D(&x, &y, &z, direction, type, 0, NULL, 0))
         return 0;
@@ -2173,17 +2173,17 @@ static void ride_spiral_slide_update(Ride *ride)
         sint32 x = ride->station_starts[i].x;
         sint32 y = ride->station_starts[i].y;
 
-        rct_tile_element *mapElement = ride_get_station_start_track_element(ride, i);
-        if (mapElement == NULL)
+        rct_tile_element *tileElement = ride_get_station_start_track_element(ride, i);
+        if (tileElement == NULL)
             continue;
 
-        sint32 rotation = tile_element_get_direction(mapElement);
+        sint32 rotation = tile_element_get_direction(tileElement);
         x *= 32;
         y *= 32;
         x += ride_spiral_slide_main_tile_offset[rotation][current_rotation].x;
         y += ride_spiral_slide_main_tile_offset[rotation][current_rotation].y;
 
-        map_invalidate_tile_zoom0(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+        map_invalidate_tile_zoom0(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
     }
 }
 
@@ -2629,7 +2629,7 @@ rct_peep *ride_find_closest_mechanic(Ride *ride, sint32 forInspection)
 {
     sint32 x, y, z, stationIndex;
     LocationXY8 location;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     // Get either exit position or entrance position if there is no exit
     stationIndex = ride->inspection_station;
@@ -2644,8 +2644,8 @@ rct_peep *ride_find_closest_mechanic(Ride *ride, sint32 forInspection)
     x = location.x;
     y = location.y;
     z = ride->station_heights[stationIndex];
-    mapElement = ride_get_station_exit_element(ride, x, y, z);
-    if (mapElement == NULL)
+    tileElement = ride_get_station_exit_element(ride, x, y, z);
+    if (tileElement == NULL)
         return NULL;
 
     x *= 32;
@@ -3197,23 +3197,23 @@ void ride_check_all_reachable()
 static sint32 ride_entrance_exit_is_reachable(LocationXY8 coordinates, Ride* ride, sint32 index)
 {
     sint32 x, y, z;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     x = coordinates.x;
     y = coordinates.y;
     z = ride->station_heights[index];
-    mapElement = map_get_first_element_at(x, y);
+    tileElement = map_get_first_element_at(x, y);
 
     for (;;) {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE && z == mapElement->base_height) {
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE && z == tileElement->base_height) {
             break;
-        } else if (tile_element_is_last_for_tile(mapElement)) {
+        } else if (tile_element_is_last_for_tile(tileElement)) {
             return 1;
         }
-        mapElement++;
+        tileElement++;
     }
 
-    uint8 face_direction = tile_element_get_direction(mapElement);
+    uint8 face_direction = tile_element_get_direction(tileElement);
 
     x *= 32;
     y *= 32;
@@ -3260,7 +3260,7 @@ static void ride_entrance_exit_connected(Ride* ride, sint32 ride_idx)
 static void ride_shop_connected(Ride* ride, sint32 ride_idx)
 {
     sint32 x, y, count;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     LocationXY8 coordinates = ride->station_starts[0];
     if (coordinates.xy == RCT_XY8_UNDEFINED)
@@ -3269,15 +3269,15 @@ static void ride_shop_connected(Ride* ride, sint32 ride_idx)
     x = coordinates.x;
     y = coordinates.y;
 
-    mapElement = map_get_first_element_at(x, y);
+    tileElement = map_get_first_element_at(x, y);
     do {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK && mapElement->properties.track.ride_index == ride_idx)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK && tileElement->properties.track.ride_index == ride_idx)
             break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     uint16 entrance_directions = 0;
-    uint8 track_type = mapElement->properties.track.type;
-    ride = get_ride(mapElement->properties.track.ride_index);
+    uint8 track_type = tileElement->properties.track.type;
+    ride = get_ride(tileElement->properties.track.ride_index);
     if (ride == NULL)
     {
         return;
@@ -3288,7 +3288,7 @@ static void ride_shop_connected(Ride* ride, sint32 ride_idx)
         entrance_directions = TrackSequenceProperties[track_type][0];
     }
 
-    uint8 tile_direction = tile_element_get_direction(mapElement);
+    uint8 tile_direction = tile_element_get_direction(tileElement);
     entrance_directions <<= tile_direction;
     entrance_directions = ((entrance_directions >> 12) | entrance_directions) & 0xF;
 
@@ -3313,7 +3313,7 @@ static void ride_shop_connected(Ride* ride, sint32 ride_idx)
         sint32 y2 = y - TileDirectionDelta[face_direction].y;
         sint32 x2 = x - TileDirectionDelta[face_direction].x;
 
-        if (map_coord_is_connected(x2 / 32, y2 / 32, mapElement->base_height, face_direction))
+        if (map_coord_is_connected(x2 / 32, y2 / 32, tileElement->base_height, face_direction))
             return;
     }
 
@@ -3331,12 +3331,12 @@ static void ride_shop_connected(Ride* ride, sint32 ride_idx)
 
 #pragma region Interface
 
-static void ride_track_set_map_tooltip(rct_tile_element *mapElement)
+static void ride_track_set_map_tooltip(rct_tile_element *tileElement)
 {
     sint32 rideIndex;
     Ride *ride;
 
-    rideIndex = mapElement->properties.track.ride_index;
+    rideIndex = tileElement->properties.track.ride_index;
     ride = get_ride(rideIndex);
 
     set_map_tooltip_format_arg(0, rct_string_id, STR_RIDE_MAP_TIP);
@@ -3350,15 +3350,15 @@ static void ride_track_set_map_tooltip(rct_tile_element *mapElement)
     set_map_tooltip_format_arg(10, uint32, arg1);
 }
 
-static void ride_station_set_map_tooltip(rct_tile_element *mapElement)
+static void ride_station_set_map_tooltip(rct_tile_element *tileElement)
 {
     sint32 i, rideIndex, stationIndex;
     Ride *ride;
 
-    rideIndex = mapElement->properties.track.ride_index;
+    rideIndex = tileElement->properties.track.ride_index;
     ride = get_ride(rideIndex);
 
-    stationIndex = tile_element_get_station(mapElement);
+    stationIndex = tile_element_get_station(tileElement);
     for (i = stationIndex; i >= 0; i--)
         if (ride->station_starts[i].xy == RCT_XY8_UNDEFINED)
             stationIndex--;
@@ -3377,21 +3377,21 @@ static void ride_station_set_map_tooltip(rct_tile_element *mapElement)
     set_map_tooltip_format_arg(16, uint32, arg1);
 }
 
-static void ride_entrance_set_map_tooltip(rct_tile_element *mapElement)
+static void ride_entrance_set_map_tooltip(rct_tile_element *tileElement)
 {
     sint32 i, rideIndex, stationIndex;
     Ride *ride;
 
-    rideIndex = mapElement->properties.track.ride_index;
+    rideIndex = tileElement->properties.track.ride_index;
     ride = get_ride(rideIndex);
 
     // Get the station
-    stationIndex = tile_element_get_station(mapElement);
+    stationIndex = tile_element_get_station(tileElement);
     for (i = stationIndex; i >= 0; i--)
         if (ride->station_starts[i].xy == RCT_XY8_UNDEFINED)
             stationIndex--;
 
-    if (mapElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
+    if (tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
         // Get the queue length
         sint32 queueLength = 0;
         if (ride->entrances[stationIndex].xy != RCT_XY8_UNDEFINED)
@@ -3412,7 +3412,7 @@ static void ride_entrance_set_map_tooltip(rct_tile_element *mapElement)
         set_map_tooltip_format_arg(16, uint16, queueLength);
     } else {
         // Get the station
-        stationIndex = tile_element_get_station(mapElement);
+        stationIndex = tile_element_get_station(tileElement);
         for (i = stationIndex; i >= 0; i--)
             if (ride->station_starts[i].xy == RCT_XY8_UNDEFINED)
                 stationIndex--;
@@ -3424,19 +3424,19 @@ static void ride_entrance_set_map_tooltip(rct_tile_element *mapElement)
     }
 }
 
-void ride_set_map_tooltip(rct_tile_element *mapElement)
+void ride_set_map_tooltip(rct_tile_element *tileElement)
 {
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
-        ride_entrance_set_map_tooltip(mapElement);
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+        ride_entrance_set_map_tooltip(tileElement);
     } else {
         if (
-            mapElement->properties.track.type == 2 ||
-            mapElement->properties.track.type == 3 ||
-            mapElement->properties.track.type == 1
+            tileElement->properties.track.type == 2 ||
+            tileElement->properties.track.type == 3 ||
+            tileElement->properties.track.type == 1
         ) {
-            ride_station_set_map_tooltip(mapElement);
+            ride_station_set_map_tooltip(tileElement);
         } else {
-            ride_track_set_map_tooltip(mapElement);
+            ride_track_set_map_tooltip(tileElement);
         }
     }
 }
@@ -4162,16 +4162,16 @@ static void sub_6B5952(sint32 rideIndex)
         sint32 y = location.y * 32;
         sint32 z = ride->station_heights[i];
 
-        rct_tile_element *mapElement = map_get_first_element_at(x / 32, y / 32);
+        rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
         do {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
-            if (mapElement->base_height != z)
+            if (tileElement->base_height != z)
                 continue;
 
-            sint32 direction = tile_element_get_direction(mapElement);
-            footpath_chain_ride_queue(rideIndex, i, x, y, mapElement, direction ^ 2);
-        } while (!tile_element_is_last_for_tile(mapElement++));
+            sint32 direction = tile_element_get_direction(tileElement);
+            footpath_chain_ride_queue(rideIndex, i, x, y, tileElement, direction ^ 2);
+        } while (!tile_element_is_last_for_tile(tileElement++));
     }
 }
 
@@ -4435,19 +4435,19 @@ static void ride_set_maze_entrance_exit_points(Ride *ride)
         sint32 y = (*position >> 8) << 5;
         sint32 z = ride->station_heights[0];
 
-        rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
             if (
-                mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE &&
-                mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT
+                tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE &&
+                tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT
             ) {
                 continue;
             }
-            if (mapElement->base_height != z) continue;
+            if (tileElement->base_height != z) continue;
 
-            maze_entrance_hedge_removal(x, y, mapElement);
-        } while (!tile_element_is_last_for_tile(mapElement++));
+            maze_entrance_hedge_removal(x, y, tileElement);
+        } while (!tile_element_is_last_for_tile(tileElement++));
     }
 }
 
@@ -4539,7 +4539,7 @@ static rct_vehicle *vehicle_create_car(
     sint32 y,
     sint32 z,
     sint32 *remainingDistance,
-    rct_tile_element *mapElement
+    rct_tile_element *tileElement
 ) {
     registers regs = { 0 };
 
@@ -4597,18 +4597,18 @@ static rct_vehicle *vehicle_create_car(
     if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_31) {
         // loc_6DDCA4:
         vehicle->var_CD = 0;
-        sint32 direction = tile_element_get_direction(mapElement);
+        sint32 direction = tile_element_get_direction(tileElement);
         x += word_9A3AB4[direction].x;
         y += word_9A3AB4[direction].y;
-        z = mapElement->base_height * 8;
+        z = tileElement->base_height * 8;
         vehicle->track_x = x;
         vehicle->track_y = y;
         vehicle->track_z = z;
-        vehicle->current_station = tile_element_get_station(mapElement);
+        vehicle->current_station = tile_element_get_station(tileElement);
 
         z += RideData5[ride->type].z_offset;
 
-        vehicle->track_type = mapElement->properties.track.type << 2;
+        vehicle->track_type = tileElement->properties.track.type << 2;
         vehicle->track_progress = 0;
         vehicle->status = 0;
         vehicle->sub_state = 0;
@@ -4655,7 +4655,7 @@ static rct_vehicle *vehicle_create_car(
         vehicle->track_x = x;
         vehicle->track_y = y;
 
-        sint32 direction = tile_element_get_direction(mapElement);
+        sint32 direction = tile_element_get_direction(tileElement);
         vehicle->sprite_direction = direction << 3;
 
         if (ride->type == RIDE_TYPE_SPACE_RINGS) {
@@ -4676,14 +4676,14 @@ static rct_vehicle *vehicle_create_car(
 
         x += word_9A2A60[direction].x;
         y += word_9A2A60[direction].y;
-        vehicle->track_z = mapElement->base_height * 8;
+        vehicle->track_z = tileElement->base_height * 8;
 
-        vehicle->current_station = tile_element_get_station(mapElement);
-        z = mapElement->base_height * 8;
+        vehicle->current_station = tile_element_get_station(tileElement);
+        z = tileElement->base_height * 8;
         z += RideData5[ride->type].z_offset;
 
         sprite_move(x, y, z, (rct_sprite*)vehicle);
-        vehicle->track_type = (mapElement->properties.track.type << 2) | (vehicle->sprite_direction >> 3);
+        vehicle->track_type = (tileElement->properties.track.type << 2) | (vehicle->sprite_direction >> 3);
         vehicle->track_progress = 31;
         if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_MINI_GOLF) {
             vehicle->track_progress = 15;
@@ -4691,7 +4691,7 @@ static rct_vehicle *vehicle_create_car(
         vehicle->update_flags = VEHICLE_UPDATE_FLAG_1;
         if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_HAS_INVERTED_SPRITE_SET)
         {
-            if (track_element_is_inverted(mapElement))
+            if (track_element_is_inverted(tileElement))
             {
                 vehicle->update_flags |= VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES;
             }
@@ -4710,14 +4710,14 @@ static rct_vehicle *vehicle_create_car(
  *
  *  rct2: 0x006DD84C
  */
-static train_ref vehicle_create_train(sint32 rideIndex, sint32 x, sint32 y, sint32 z, sint32 vehicleIndex, sint32 *remainingDistance, rct_tile_element *mapElement)
+static train_ref vehicle_create_train(sint32 rideIndex, sint32 x, sint32 y, sint32 z, sint32 vehicleIndex, sint32 *remainingDistance, rct_tile_element *tileElement)
 {
     Ride *ride = get_ride(rideIndex);
 
     train_ref train = { NULL, NULL };
     for (sint32 carIndex = 0; carIndex < ride->num_cars_per_train; carIndex++) {
         const uint8 vehicle = ride_entry_get_vehicle_at_position(ride->subtype, ride->num_cars_per_train, carIndex);
-        rct_vehicle *car = vehicle_create_car(rideIndex, vehicle, carIndex, vehicleIndex, x, y, z, remainingDistance, mapElement);
+        rct_vehicle *car = vehicle_create_car(rideIndex, vehicle, carIndex, vehicleIndex, x, y, z, remainingDistance, tileElement);
         if (carIndex == 0) {
             train.head = car;
         } else {
@@ -4731,7 +4731,7 @@ static train_ref vehicle_create_train(sint32 rideIndex, sint32 x, sint32 y, sint
     return train;
 }
 
-static void vehicle_create_trains(sint32 rideIndex, sint32 x, sint32 y, sint32 z, rct_tile_element *mapElement)
+static void vehicle_create_trains(sint32 rideIndex, sint32 x, sint32 y, sint32 z, rct_tile_element *tileElement)
 {
     Ride *ride = get_ride(rideIndex);
     train_ref firstTrain = { 0 }, lastTrain = { 0 };
@@ -4741,7 +4741,7 @@ static void vehicle_create_trains(sint32 rideIndex, sint32 x, sint32 y, sint32 z
         if (ride_is_block_sectioned(ride)) {
             remainingDistance = 0;
         }
-        train_ref train = vehicle_create_train(rideIndex, x, y, z, vehicleIndex, &remainingDistance, mapElement);
+        train_ref train = vehicle_create_train(rideIndex, x, y, z, vehicleIndex, &remainingDistance, tileElement);
         if (vehicleIndex == 0) {
             firstTrain = train;
         } else {
@@ -4819,17 +4819,17 @@ static void ride_create_vehicles_find_first_block(Ride *ride, rct_xy_element *ou
         case TRACK_ELEM_DIAG_25_DEG_UP_TO_FLAT:
         case TRACK_ELEM_DIAG_60_DEG_UP_TO_FLAT:
             if (track_element_is_lift_hill(trackElement)) {
-                rct_tile_element *mapElement = map_get_first_element_at(trackBeginEnd.begin_x >> 5, trackBeginEnd.begin_y >> 5);
+                rct_tile_element *tileElement = map_get_first_element_at(trackBeginEnd.begin_x >> 5, trackBeginEnd.begin_y >> 5);
                 do {
-                    if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-                    if (mapElement->properties.track.type != trackType) continue;
-                    if (tile_element_get_track_sequence(mapElement) != 0) continue;
-                    if (mapElement->base_height != trackBeginEnd.begin_z / 8) continue;
+                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+                    if (tileElement->properties.track.type != trackType) continue;
+                    if (tile_element_get_track_sequence(tileElement) != 0) continue;
+                    if (tileElement->base_height != trackBeginEnd.begin_z / 8) continue;
                     outXYElement->x = trackBeginEnd.begin_x;
                     outXYElement->y = trackBeginEnd.begin_y;
-                    outXYElement->element = mapElement;
+                    outXYElement->element = tileElement;
                     return;
-                } while (!tile_element_is_last_for_tile(mapElement++));
+                } while (!tile_element_is_last_for_tile(tileElement++));
             }
             break;
         case TRACK_ELEM_END_STATION:
@@ -4869,29 +4869,29 @@ static bool ride_create_vehicles(Ride *ride, sint32 rideIndex, rct_xy_element *e
         return true;
     }
 
-    rct_tile_element *mapElement = element->element;
+    rct_tile_element *tileElement = element->element;
     sint32 x = element->x;
     sint32 y = element->y;
     sint32 z = element->element->base_height;
-    sint32 direction = tile_element_get_direction(mapElement);
+    sint32 direction = tile_element_get_direction(tileElement);
 
     //
     if (ride->mode == RIDE_MODE_STATION_TO_STATION) {
         x = element->x - TileDirectionDelta[direction].x;
         y = element->y - TileDirectionDelta[direction].y;
 
-        mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do {
-            if (mapElement->base_height != z) continue;
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+            if (tileElement->base_height != z) continue;
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
             break;
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
 
-        z = mapElement->base_height;
-        direction = tile_element_get_direction(mapElement);
+        z = tileElement->base_height;
+        direction = tile_element_get_direction(tileElement);
     }
 
-    vehicle_create_trains(rideIndex, x, y, z, mapElement);
+    vehicle_create_trains(rideIndex, x, y, z, tileElement);
     // return true;
 
     // Initialise station departs
@@ -4929,7 +4929,7 @@ static bool ride_create_vehicles(Ride *ride, sint32 rideIndex, rct_xy_element *e
  *
  *  rct2: 0x006DDF9C
  */
-void loc_6DDF9C(Ride *ride, rct_tile_element *mapElement)
+void loc_6DDF9C(Ride *ride, rct_tile_element *tileElement)
 {
     rct_vehicle *train, *car;
 
@@ -4944,7 +4944,7 @@ void loc_6DDF9C(Ride *ride, rct_tile_element *mapElement)
         vehicle_update_track_motion(train, NULL);
 
         do {
-            mapElement->flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
+            tileElement->flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
             car = train;
             while (true) {
                 car->velocity = 0;
@@ -4960,7 +4960,7 @@ void loc_6DDF9C(Ride *ride, rct_tile_element *mapElement)
             }
         } while (!(vehicle_update_track_motion(train, NULL) & VEHICLE_UPDATE_MOTION_TRACK_FLAG_10));
 
-        mapElement->flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
+        tileElement->flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
         car = train;
         while (true) {
             car->update_flags &= ~VEHICLE_UPDATE_FLAG_1;
@@ -5001,17 +5001,17 @@ static bool ride_initialise_cable_lift_track(Ride *ride, bool isApplying)
     sint32 z = ride->station_heights[stationIndex];
 
     bool success = false;
-    rct_tile_element *mapElement = map_get_first_element_at(location.x, location.y);
+    rct_tile_element *tileElement = map_get_first_element_at(location.x, location.y);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-        if (mapElement->base_height != z) continue;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->base_height != z) continue;
 
-        if (!(TrackSequenceProperties[mapElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) {
+        if (!(TrackSequenceProperties[tileElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) {
             continue;
         }
         success = true;
         break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     if (!success)
         return false;
@@ -5027,11 +5027,11 @@ static bool ride_initialise_cable_lift_track(Ride *ride, bool isApplying)
     track_circuit_iterator_begin(&it, (rct_xy_element){
         .x = x,
         .y = y,
-        .element = mapElement
+        .element = tileElement
     });
     while (track_circuit_iterator_previous(&it)) {
-        mapElement = it.current.element;
-        sint32 trackType = mapElement->properties.track.type;
+        tileElement = it.current.element;
+        sint32 trackType = tileElement->properties.track.type;
 
         uint16 flags = 16;
         switch (state) {
@@ -5065,12 +5065,12 @@ static bool ride_initialise_cable_lift_track(Ride *ride, bool isApplying)
             break;
         }
         if (isApplying) {
-            z = mapElement->base_height * 8;
-            sint32 direction = tile_element_get_direction(mapElement);
-            trackType = mapElement->properties.track.type;
+            z = tileElement->base_height * 8;
+            sint32 direction = tile_element_get_direction(tileElement);
+            trackType = tileElement->properties.track.type;
             x = it.current.x;
             y = it.current.y;
-            sub_6C683D(&x, &y, &z, direction, trackType, 0, &mapElement, flags);
+            sub_6C683D(&x, &y, &z, direction, trackType, 0, &tileElement, flags);
         }
     }
     return true;
@@ -5112,13 +5112,13 @@ static bool ride_create_cable_lift(sint32 rideIndex, bool isApplying)
     sint32 x = ride->cable_lift_x;
     sint32 y = ride->cable_lift_y;
     sint32 z = ride->cable_lift_z;
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-        if (mapElement->base_height != z) continue;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->base_height != z) continue;
         break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
-    sint32 direction = tile_element_get_direction(mapElement);
+    } while (!tile_element_is_last_for_tile(tileElement++));
+    sint32 direction = tile_element_get_direction(tileElement);
 
     rct_vehicle *head = NULL;
     rct_vehicle *tail = NULL;
@@ -5227,22 +5227,22 @@ static void ride_scroll_to_track_error(rct_xy_element *trackElement)
 static rct_tile_element *loc_6B4F6B(sint32 rideIndex, sint32 x, sint32 y)
 {
     Ride * ride = get_ride(rideIndex);
-    rct_tile_element *mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (RideProperties[ride->type].flags & RIDE_TYPE_FLAG_FLAT_RIDE) {
-            if (!(FlatRideTrackSequenceProperties[mapElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN))
+            if (!(FlatRideTrackSequenceProperties[tileElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN))
                 continue;
         } else {
-            if (!(TrackSequenceProperties[mapElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN))
+            if (!(TrackSequenceProperties[tileElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN))
                 continue;
         }
 
-        if (mapElement->properties.track.ride_index == rideIndex)
-            return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        if (tileElement->properties.track.ride_index == rideIndex)
+            return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
@@ -6592,27 +6592,27 @@ void ride_get_entrance_or_exit_position_from_screen_position(sint32 screenX, sin
     sint16            mapX, mapY;
     sint16            entranceMinX, entranceMinY, entranceMaxX, entranceMaxY, word_F4418C, word_F4418E;
     sint32            interactionType, direction, stationHeight, stationDirection;
-    rct_tile_element * mapElement;
+    rct_tile_element * tileElement;
     rct_viewport    * viewport;
     Ride            * ride;
 
     gRideEntranceExitPlaceDirection = 255;
-    get_map_coordinates_from_pos(screenX, screenY, 0xFFFB, &mapX, &mapY, &interactionType, &mapElement, &viewport);
+    get_map_coordinates_from_pos(screenX, screenY, 0xFFFB, &mapX, &mapY, &interactionType, &tileElement, &viewport);
     if (interactionType != 0)
     {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
         {
-            if (mapElement->properties.track.ride_index == gRideEntranceExitPlaceRideIndex)
+            if (tileElement->properties.track.ride_index == gRideEntranceExitPlaceRideIndex)
             {
-                if (TrackSequenceProperties[mapElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)
+                if (TrackSequenceProperties[tileElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)
                 {
-                    if (mapElement->properties.track.type == TRACK_ELEM_MAZE)
+                    if (tileElement->properties.track.type == TRACK_ELEM_MAZE)
                     {
                         gRideEntranceExitPlaceStationIndex = 0;
                     }
                     else
                     {
-                        gRideEntranceExitPlaceStationIndex = tile_element_get_station(mapElement);
+                        gRideEntranceExitPlaceStationIndex = tile_element_get_station(tileElement);
                     }
                 }
             }
@@ -6664,33 +6664,33 @@ void ride_get_entrance_or_exit_position_from_screen_position(sint32 screenX, sin
             mapY = _unkF44188.y + TileDirectionDelta[direction].y;
             if (mapX >= 0 && mapY >= 0 && mapX < (256 * 32) && mapY < (256 * 32))
             {
-                mapElement = map_get_first_element_at(mapX >> 5, mapY >> 5);
+                tileElement = map_get_first_element_at(mapX >> 5, mapY >> 5);
                 do
                 {
-                    if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                         continue;
-                    if (mapElement->base_height != stationHeight)
+                    if (tileElement->base_height != stationHeight)
                         continue;
-                    if (mapElement->properties.track.ride_index != gRideEntranceExitPlaceRideIndex)
+                    if (tileElement->properties.track.ride_index != gRideEntranceExitPlaceRideIndex)
                         continue;
-                    if (mapElement->properties.track.type == TRACK_ELEM_INVERTED_90_DEG_UP_TO_FLAT_QUARTER_LOOP)
+                    if (tileElement->properties.track.type == TRACK_ELEM_INVERTED_90_DEG_UP_TO_FLAT_QUARTER_LOOP)
                     {
                         gRideEntranceExitPlaceDirection = direction ^ 2;
                         *outDirection = direction ^ 2;
                         return;
                     }
-                    if (tile_element_get_station(mapElement) != gRideEntranceExitPlaceStationIndex)
+                    if (tile_element_get_station(tileElement) != gRideEntranceExitPlaceStationIndex)
                         continue;
 
-                    sint32 eax = (direction + 2 - tile_element_get_direction(mapElement)) & TILE_ELEMENT_DIRECTION_MASK;
-                    if (FlatRideTrackSequenceProperties[mapElement->properties.track.type][tile_element_get_track_sequence(mapElement)] & (1 << eax))
+                    sint32 eax = (direction + 2 - tile_element_get_direction(tileElement)) & TILE_ELEMENT_DIRECTION_MASK;
+                    if (FlatRideTrackSequenceProperties[tileElement->properties.track.type][tile_element_get_track_sequence(tileElement)] & (1 << eax))
                     {
                         gRideEntranceExitPlaceDirection = direction ^ 2;
                         *outDirection = direction ^ 2;
                         return;
                     }
                 }
-                while (!tile_element_is_last_for_tile(mapElement++));
+                while (!tile_element_is_last_for_tile(tileElement++));
             }
             direction = (direction + 1) & 3;
         }
@@ -6703,13 +6703,13 @@ void ride_get_entrance_or_exit_position_from_screen_position(sint32 screenX, sin
         entranceMinX = mapX;
         entranceMinY = mapY;
 
-        mapElement = ride_get_station_start_track_element(ride, gRideEntranceExitPlaceStationIndex);
-        if (mapElement == NULL)
+        tileElement = ride_get_station_start_track_element(ride, gRideEntranceExitPlaceStationIndex);
+        if (tileElement == NULL)
         {
             *outX = 0x8000;
             return;
         }
-        direction        = tile_element_get_direction(mapElement);
+        direction        = tile_element_get_direction(tileElement);
         stationDirection = direction;
 
         while (true)
@@ -6718,19 +6718,19 @@ void ride_get_entrance_or_exit_position_from_screen_position(sint32 screenX, sin
             entranceMaxY = mapY;
             mapX -= TileDirectionDelta[direction].x;
             mapY -= TileDirectionDelta[direction].y;
-            mapElement = map_get_first_element_at(mapX >> 5, mapY >> 5);
+            tileElement = map_get_first_element_at(mapX >> 5, mapY >> 5);
             bool goToNextTile = false;
 
             do
             {
-                if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                     continue;
-                if (mapElement->properties.track.ride_index != gRideEntranceExitPlaceRideIndex)
+                if (tileElement->properties.track.ride_index != gRideEntranceExitPlaceRideIndex)
                     continue;
-                if (tile_element_get_station(mapElement) != gRideEntranceExitPlaceStationIndex)
+                if (tile_element_get_station(tileElement) != gRideEntranceExitPlaceStationIndex)
                     continue;
 
-                switch (mapElement->properties.track.type)
+                switch (tileElement->properties.track.type)
                 {
                 case TRACK_ELEM_END_STATION:
                 case TRACK_ELEM_BEGIN_STATION:
@@ -6738,7 +6738,7 @@ void ride_get_entrance_or_exit_position_from_screen_position(sint32 screenX, sin
                     goToNextTile = true;
                 }
             }
-            while (!goToNextTile && !tile_element_is_last_for_tile(mapElement++));
+            while (!goToNextTile && !tile_element_is_last_for_tile(tileElement++));
 
             if (!goToNextTile)
                 break;
@@ -7032,7 +7032,7 @@ static sint32 ride_get_smallest_station_length(Ride *ride)
 static sint32 ride_get_track_length(Ride * ride)
 {
     rct_window             * w;
-    rct_tile_element        * mapElement = NULL;
+    rct_tile_element        * tileElement = NULL;
     track_circuit_iterator   it;
     sint32                   x = 0, y = 0, z, trackType, rideIndex, result;
     bool                     foundTrack = false;
@@ -7047,27 +7047,27 @@ static sint32 ride_get_track_length(Ride * ride)
         y = location.y * 32;
         z = ride->station_heights[i];
 
-        mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do
         {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                 continue;
 
-            trackType = mapElement->properties.track.type;
+            trackType = tileElement->properties.track.type;
             if (!(TrackSequenceProperties[trackType][0] & TRACK_SEQUENCE_FLAG_ORIGIN))
                 continue;
 
-            if (mapElement->base_height != z)
+            if (tileElement->base_height != z)
                 continue;
 
             foundTrack = true;
         }
-        while (!foundTrack && !tile_element_is_last_for_tile(mapElement++));
+        while (!foundTrack && !tile_element_is_last_for_tile(tileElement++));
     }
 
     if (foundTrack)
     {
-        rideIndex = mapElement->properties.track.ride_index;
+        rideIndex = tileElement->properties.track.ride_index;
 
         w = window_find_by_class(WC_RIDE_CONSTRUCTION);
         if (w != NULL && _rideConstructionState != RIDE_CONSTRUCTION_STATE_0 && _currentRideIndex == rideIndex)
@@ -7076,7 +7076,7 @@ static sint32 ride_get_track_length(Ride * ride)
         }
 
         result = 0;
-        track_circuit_iterator_begin(&it, (rct_xy_element) {x, y, mapElement});
+        track_circuit_iterator_begin(&it, (rct_xy_element) {x, y, tileElement});
         while (track_circuit_iterator_next(&it))
         {
             trackType = it.current.element->properties.track.type;
@@ -7454,33 +7454,33 @@ void sub_6CB945(sint32 rideIndex)
             uint8 direction = 0xFF;
 
             bool specialTrack = false;
-            rct_tile_element* mapElement = NULL;
+            rct_tile_element* tileElement = NULL;
 
             while (true) {
                 if (direction != 0xFF) {
                     location.x -= TileDirectionDelta[direction].x;
                     location.y -= TileDirectionDelta[direction].y;
                 }
-                mapElement = map_get_first_element_at(location.x >> 5, location.y >> 5);
+                tileElement = map_get_first_element_at(location.x >> 5, location.y >> 5);
 
                 bool trackFound = false;
                 do {
-                    if (mapElement->base_height != location.z) continue;
-                    if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-                    if (mapElement->properties.track.ride_index != rideIndex) continue;
-                    if (tile_element_get_track_sequence(mapElement) != 0) continue;
-                    if (!(TrackSequenceProperties[mapElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) continue;
+                    if (tileElement->base_height != location.z) continue;
+                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+                    if (tileElement->properties.track.ride_index != rideIndex) continue;
+                    if (tile_element_get_track_sequence(tileElement) != 0) continue;
+                    if (!(TrackSequenceProperties[tileElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) continue;
 
                     trackFound = true;
                     break;
-                } while (!tile_element_is_last_for_tile(mapElement++));
+                } while (!tile_element_is_last_for_tile(tileElement++));
 
                 if (trackFound == false) {
                     break;
                 }
 
-                tile_element_set_station(mapElement, stationId);
-                direction = tile_element_get_direction(mapElement);
+                tile_element_set_station(tileElement, stationId);
+                direction = tile_element_get_direction(tileElement);
 
                 if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3)) {
                     specialTrack = true;
@@ -7492,27 +7492,27 @@ void sub_6CB945(sint32 rideIndex)
                 continue;
             }
 
-            const rct_preview_track *trackBlock = get_track_def_from_ride(ride, mapElement->properties.track.type);
+            const rct_preview_track *trackBlock = get_track_def_from_ride(ride, tileElement->properties.track.type);
             while ((++trackBlock)->index != 0xFF) {
                 LocationXYZ16 blockLocation = location;
                 map_offset_with_rotation(&blockLocation.x, &blockLocation.y, trackBlock->x, trackBlock->y, direction);
 
                 bool trackFound = false;
-                mapElement = map_get_first_element_at(blockLocation.x >> 5, blockLocation.y >> 5);
+                tileElement = map_get_first_element_at(blockLocation.x >> 5, blockLocation.y >> 5);
                 do {
-                    if (blockLocation.z != mapElement->base_height) continue;
-                    if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-                    if (!(TrackSequenceProperties[mapElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) continue;
+                    if (blockLocation.z != tileElement->base_height) continue;
+                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+                    if (!(TrackSequenceProperties[tileElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) continue;
 
                     trackFound = true;
                     break;
-                } while (!tile_element_is_last_for_tile(mapElement++));
+                } while (!tile_element_is_last_for_tile(tileElement++));
 
                 if (!trackFound) {
                     break;
                 }
 
-                tile_element_set_station(mapElement, stationId);
+                tile_element_set_station(tileElement, stationId);
             }
         }
     }
@@ -7555,27 +7555,27 @@ void sub_6CB945(sint32 rideIndex)
             .y = ((*locationList >> 8) & 0xFF) * 32
         };
 
-        rct_tile_element *mapElement = map_get_first_element_at(location.x >> 5, location.y >> 5);
+        rct_tile_element *tileElement = map_get_first_element_at(location.x >> 5, location.y >> 5);
         do {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
-            if (mapElement->properties.entrance.ride_index != rideIndex) continue;
-            if (mapElement->properties.entrance.type > ENTRANCE_TYPE_RIDE_EXIT) continue;
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+            if (tileElement->properties.entrance.ride_index != rideIndex) continue;
+            if (tileElement->properties.entrance.type > ENTRANCE_TYPE_RIDE_EXIT) continue;
 
             LocationXY16 nextLocation = location;
-            nextLocation.x += TileDirectionDelta[tile_element_get_direction(mapElement)].x;
-            nextLocation.y += TileDirectionDelta[tile_element_get_direction(mapElement)].y;
+            nextLocation.x += TileDirectionDelta[tile_element_get_direction(tileElement)].x;
+            nextLocation.y += TileDirectionDelta[tile_element_get_direction(tileElement)].y;
 
             bool shouldRemove = true;
             rct_tile_element *trackElement = map_get_first_element_at(nextLocation.x >> 5, nextLocation.y >> 5);
             do {
                 if (tile_element_get_type(trackElement) != TILE_ELEMENT_TYPE_TRACK) continue;
                 if (trackElement->properties.track.ride_index != rideIndex) continue;
-                if (trackElement->base_height != mapElement->base_height) continue;
+                if (trackElement->base_height != tileElement->base_height) continue;
 
                 uint8 trackType = trackElement->properties.track.type;
-                uint8 trackSequence = tile_element_get_track_sequence(mapElement);
+                uint8 trackSequence = tile_element_get_track_sequence(tileElement);
 
-                uint8 direction = (tile_element_get_direction(mapElement) - tile_element_get_direction(trackElement) + 2) & 3;
+                uint8 direction = (tile_element_get_direction(tileElement) - tile_element_get_direction(trackElement) + 2) & 3;
 
                 if (!(TrackSequenceProperties[trackType][trackSequence] & (1 << direction))) {
                     continue;
@@ -7586,7 +7586,7 @@ void sub_6CB945(sint32 rideIndex)
                     stationId = tile_element_get_station(trackElement);
                 }
 
-                if (mapElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT) {
+                if (tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT) {
                     if (ride->exits[stationId].xy != RCT_XY8_UNDEFINED) {
                         break;
                     }
@@ -7600,21 +7600,21 @@ void sub_6CB945(sint32 rideIndex)
                     ride->entrances[stationId].y = location.y / 32;
                 }
 
-                mapElement->properties.entrance.index &= 0x8F;
-                mapElement->properties.entrance.index |= stationId << 4;
+                tileElement->properties.entrance.index &= 0x8F;
+                tileElement->properties.entrance.index |= stationId << 4;
                 shouldRemove = false;
             } while (!tile_element_is_last_for_tile(trackElement++));
 
             if (shouldRemove == true) {
                 footpath_queue_chain_reset();
-                maze_entrance_hedge_replacement(location.x, location.y, mapElement);
-                footpath_remove_edges_at(location.x, location.y, mapElement);
+                maze_entrance_hedge_replacement(location.x, location.y, tileElement);
+                footpath_remove_edges_at(location.x, location.y, tileElement);
                 footpath_update_queue_chains();
                 map_invalidate_tile_full(location.x, location.y);
-                tile_element_remove(mapElement);
-                mapElement--;
+                tile_element_remove(tileElement);
+                tileElement--;
             }
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
     }
 }
 
@@ -7880,31 +7880,31 @@ money16 ride_get_price(Ride * ride)
  * Returns NULL if no suitable tile_element is found.
  */
 rct_tile_element *get_station_platform(sint32 x, sint32 y, sint32 z, sint32 z_tolerance) {
-    bool foundMapElement = false;
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
-    if (mapElement != NULL) {
+    bool foundTileElement = false;
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
+    if (tileElement != NULL) {
         do {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-            /* Check if mapElement is a station platform. */
-            if (!track_element_is_station(mapElement)) continue;
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+            /* Check if tileElement is a station platform. */
+            if (!track_element_is_station(tileElement)) continue;
 
-            if (z - z_tolerance > mapElement->base_height ||
-                z + z_tolerance < mapElement->base_height
+            if (z - z_tolerance > tileElement->base_height ||
+                z + z_tolerance < tileElement->base_height
             ) {
-                /* The base height if mapElement is not within
+                /* The base height if tileElement is not within
                  * the z tolerance. */
                 continue;
             }
 
-            foundMapElement = true;
+            foundTileElement = true;
             break;
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
     }
-    if (!foundMapElement) {
+    if (!foundTileElement) {
         return NULL;
     }
 
-    return mapElement;
+    return tileElement;
 }
 
 /**
@@ -8245,14 +8245,14 @@ void fix_ride_entrance_and_exit_locations()
             uint8                   entranceExitHeight = ride->station_heights[stationIndex];
             bool                    fixEntrance        = false;
             bool                    fixExit            = false;
-            const rct_tile_element * mapElement;
+            const rct_tile_element * tileElement;
 
             // Skip if the station has no entrance
             if (entranceLoc.xy != RCT_XY8_UNDEFINED)
             {
-                mapElement = map_get_ride_entrance_element_at(entranceLoc.x * 32, entranceLoc.y * 32, entranceExitHeight, false);
+                tileElement = map_get_ride_entrance_element_at(entranceLoc.x * 32, entranceLoc.y * 32, entranceExitHeight, false);
 
-                if (mapElement == NULL || mapElement->properties.entrance.ride_index != rideIndex || tile_element_get_station(mapElement) != stationIndex)
+                if (tileElement == NULL || tileElement->properties.entrance.ride_index != rideIndex || tile_element_get_station(tileElement) != stationIndex)
                 {
                     fixEntrance = true;
                 }
@@ -8260,9 +8260,9 @@ void fix_ride_entrance_and_exit_locations()
 
             if (exitLoc.xy != RCT_XY8_UNDEFINED)
             {
-                mapElement = map_get_ride_exit_element_at(exitLoc.x * 32, exitLoc.y * 32, entranceExitHeight, false);
+                tileElement = map_get_ride_exit_element_at(exitLoc.x * 32, exitLoc.y * 32, entranceExitHeight, false);
 
-                if (mapElement == NULL || mapElement->properties.entrance.ride_index != rideIndex || tile_element_get_station(mapElement) != stationIndex)
+                if (tileElement == NULL || tileElement->properties.entrance.ride_index != rideIndex || tile_element_get_station(tileElement) != stationIndex)
                 {
                     fixExit = true;
                 }
@@ -8281,30 +8281,30 @@ void fix_ride_entrance_and_exit_locations()
             {
                 for (uint8 y = 1; y < MAXIMUM_MAP_SIZE_TECHNICAL - 1; y++)
                 {
-                    mapElement = map_get_first_element_at(x, y);
+                    tileElement = map_get_first_element_at(x, y);
 
-                    if (mapElement != NULL)
+                    if (tileElement != NULL)
                     {
                         do
                         {
-                            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+                            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
                             {
                                 continue;
                             }
-                            if (mapElement->properties.entrance.ride_index != rideIndex)
+                            if (tileElement->properties.entrance.ride_index != rideIndex)
                             {
                                 continue;
                             }
-                            if (tile_element_get_station(mapElement) != stationIndex)
+                            if (tile_element_get_station(tileElement) != stationIndex)
                             {
                                 continue;
                             }
 
-                            if (fixEntrance && mapElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE)
+                            if (fixEntrance && tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE)
                             {
                                 // There are some cases (like Belmont Shores), where there is both a sunk and a disconnected entrance.
                                 // Not sure why, but in this case, pick the highest one.
-                                if (alreadyFoundEntrance && ride->station_heights[stationIndex] > mapElement->base_height)
+                                if (alreadyFoundEntrance && ride->station_heights[stationIndex] > tileElement->base_height)
                                 {
                                     continue;
                                 }
@@ -8312,15 +8312,15 @@ void fix_ride_entrance_and_exit_locations()
                                 // Found our entrance
                                 ride->entrances[stationIndex].x = x;
                                 ride->entrances[stationIndex].y = y;
-                                ride->station_heights[stationIndex] = mapElement->base_height;
+                                ride->station_heights[stationIndex] = tileElement->base_height;
 
                                 alreadyFoundEntrance = true;
 
-                                log_info("Fixed disconnected entrance of ride %d, station %d to x = %d, y = %d and z = %d.", rideIndex, stationIndex, x, y, mapElement->base_height);
+                                log_info("Fixed disconnected entrance of ride %d, station %d to x = %d, y = %d and z = %d.", rideIndex, stationIndex, x, y, tileElement->base_height);
                             }
-                            else if (fixExit && mapElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT)
+                            else if (fixExit && tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT)
                             {
-                                if (alreadyFoundExit && ride->station_heights[stationIndex] > mapElement->base_height)
+                                if (alreadyFoundExit && ride->station_heights[stationIndex] > tileElement->base_height)
                                 {
                                     continue;
                                 }
@@ -8328,14 +8328,14 @@ void fix_ride_entrance_and_exit_locations()
                                 // Found our exit
                                 ride->exits[stationIndex].x = x;
                                 ride->exits[stationIndex].y = y;
-                                ride->station_heights[stationIndex] = mapElement->base_height;
+                                ride->station_heights[stationIndex] = tileElement->base_height;
 
                                 alreadyFoundExit = true;
 
-                                log_info("Fixed disconnected exit of ride %d, station %d to x = %d, y = %d and z = %d.", rideIndex, stationIndex, x, y, mapElement->base_height);
+                                log_info("Fixed disconnected exit of ride %d, station %d to x = %d, y = %d and z = %d.", rideIndex, stationIndex, x, y, tileElement->base_height);
                             }
                         }
-                        while (!tile_element_is_last_for_tile(mapElement++));
+                        while (!tile_element_is_last_for_tile(tileElement++));
                     }
                 }
             }
diff --git a/src/openrct2/ride/ride.h b/src/openrct2/ride/ride.h
index 679f789834..5ef80781a4 100644
--- a/src/openrct2/ride/ride.h
+++ b/src/openrct2/ride/ride.h
@@ -1067,7 +1067,7 @@ sint32 ride_is_valid_for_test(sint32 rideIndex, sint32 goingToBeOpen, sint32 isA
 sint32 ride_initialise_construction_window(sint32 rideIndex);
 void ride_construction_invalidate_current_track();
 sint32 sub_6C683D(sint32* x, sint32* y, sint32* z, sint32 direction, sint32 type, uint16 extra_params, rct_tile_element** output_element, uint16 flags);
-void ride_set_map_tooltip(rct_tile_element *mapElement);
+void ride_set_map_tooltip(rct_tile_element *tileElement);
 sint32 ride_music_params_update(sint16 x, sint16 y, sint16 z, uint8 rideIndex, uint16 sampleRate, uint32 position, uint8 *tuneId);
 void ride_music_update_final();
 void ride_prepare_breakdown(sint32 rideIndex, sint32 breakdownReason);
@@ -1137,7 +1137,7 @@ void ride_construction_set_default_next_piece();
 bool track_block_get_next(rct_xy_element *input, rct_xy_element *output, sint32 *z, sint32 *direction);
 bool track_block_get_next_from_zero(sint16 x, sint16 y, sint16 z_start, uint8 rideIndex, uint8 direction_start, rct_xy_element *output, sint32 *z, sint32 *direction);
 
-bool track_block_get_previous(sint32 x, sint32 y, rct_tile_element *mapElement, track_begin_end *outTrackBeginEnd);
+bool track_block_get_previous(sint32 x, sint32 y, rct_tile_element *tileElement, track_begin_end *outTrackBeginEnd);
 bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 rideIndex, uint8 direction, track_begin_end *outTrackBeginEnd);
 
 void window_ride_construction_update_active_elements();
diff --git a/src/openrct2/ride/ride_ratings.c b/src/openrct2/ride/ride_ratings.c
index 8d111fd1a0..65abe8101c 100644
--- a/src/openrct2/ride/ride_ratings.c
+++ b/src/openrct2/ride/ride_ratings.c
@@ -80,7 +80,7 @@ static void ride_ratings_update_state_5();
 static void ride_ratings_begin_proximity_loop();
 static void ride_ratings_calculate(Ride *ride);
 static void ride_ratings_calculate_value(Ride *ride);
-static void ride_ratings_score_close_proximity(rct_tile_element *mapElement);
+static void ride_ratings_score_close_proximity(rct_tile_element *tileElement);
 
 static void ride_ratings_add(rating_tuple * rating, sint32 excitement, sint32 intensity, sint32 nausea);
 
@@ -193,31 +193,31 @@ static void ride_ratings_update_state_2()
     sint32 z = gRideRatingsCalcData.proximity_z / 8;
     sint32 trackType = gRideRatingsCalcData.proximity_track_type;
 
-    rct_tile_element *mapElement = map_get_first_element_at(x, y);
+    rct_tile_element *tileElement = map_get_first_element_at(x, y);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
 
         if (
             trackType == 255 ||
-            (tile_element_get_track_sequence(mapElement) == 0 && trackType == mapElement->properties.track.type))
+            (tile_element_get_track_sequence(tileElement) == 0 && trackType == tileElement->properties.track.type))
         {
             if (trackType == TRACK_ELEM_END_STATION) {
-                sint32 entranceIndex = tile_element_get_station(mapElement);
+                sint32 entranceIndex = tile_element_get_station(tileElement);
                 gRideRatingsCalcData.station_flags &= ~RIDE_RATING_STATION_FLAG_NO_ENTRANCE;
                 if (ride->entrances[entranceIndex].xy == RCT_XY8_UNDEFINED) {
                     gRideRatingsCalcData.station_flags |= RIDE_RATING_STATION_FLAG_NO_ENTRANCE;
                 }
             }
 
-            ride_ratings_score_close_proximity(mapElement);
+            ride_ratings_score_close_proximity(tileElement);
 
             rct_xy_element trackElement = {
                 .x = gRideRatingsCalcData.proximity_x,
                 .y = gRideRatingsCalcData.proximity_y,
-                .element = mapElement
+                .element = tileElement
             };
             rct_xy_element nextTrackElement;
             if (!track_block_get_next(&trackElement, &nextTrackElement, NULL, NULL)) {
@@ -228,7 +228,7 @@ static void ride_ratings_update_state_2()
             x = nextTrackElement.x;
             y = nextTrackElement.y;
             z = nextTrackElement.element->base_height * 8;
-            mapElement = nextTrackElement.element;
+            tileElement = nextTrackElement.element;
             if (x == gRideRatingsCalcData.proximity_start_x && y == gRideRatingsCalcData.proximity_start_y && z == gRideRatingsCalcData.proximity_start_z) {
                 gRideRatingsCalcData.state = RIDE_RATINGS_STATE_CALCULATE;
                 return;
@@ -236,10 +236,10 @@ static void ride_ratings_update_state_2()
             gRideRatingsCalcData.proximity_x = x;
             gRideRatingsCalcData.proximity_y = y;
             gRideRatingsCalcData.proximity_z = z;
-            gRideRatingsCalcData.proximity_track_type = mapElement->properties.track.type;
+            gRideRatingsCalcData.proximity_track_type = tileElement->properties.track.type;
             return;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     gRideRatingsCalcData.state = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
 }
@@ -290,20 +290,20 @@ static void ride_ratings_update_state_5()
     sint32 z = gRideRatingsCalcData.proximity_z / 8;
     sint32 trackType = gRideRatingsCalcData.proximity_track_type;
 
-    rct_tile_element *mapElement = map_get_first_element_at(x, y);
+    rct_tile_element *tileElement = map_get_first_element_at(x, y);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
 
-        if (trackType == 255 || trackType == mapElement->properties.track.type) {
-            ride_ratings_score_close_proximity(mapElement);
+        if (trackType == 255 || trackType == tileElement->properties.track.type) {
+            ride_ratings_score_close_proximity(tileElement);
 
             x = gRideRatingsCalcData.proximity_x;
             y = gRideRatingsCalcData.proximity_y;
             track_begin_end trackBeginEnd;
-            if (!track_block_get_previous(x, y, mapElement, &trackBeginEnd)) {
+            if (!track_block_get_previous(x, y, tileElement, &trackBeginEnd)) {
                 gRideRatingsCalcData.state = RIDE_RATINGS_STATE_CALCULATE;
                 return;
             }
@@ -321,7 +321,7 @@ static void ride_ratings_update_state_5()
             gRideRatingsCalcData.proximity_track_type = trackBeginEnd.begin_element->properties.track.type;
             return;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     gRideRatingsCalcData.state = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
 }
@@ -377,39 +377,39 @@ static void proximity_score_increment(sint32 type)
  *
  *  rct2: 0x006B6207
  */
-static void ride_ratings_score_close_proximity_in_direction(rct_tile_element *inputMapElement, sint32 direction)
+static void ride_ratings_score_close_proximity_in_direction(rct_tile_element *inputTileElement, sint32 direction)
 {
     sint32 x = gRideRatingsCalcData.proximity_x + TileDirectionDelta[direction].x;
     sint32 y = gRideRatingsCalcData.proximity_y + TileDirectionDelta[direction].y;
     if (x < 0 || y < 0 || x >= (32 * 256) || y >= (32 * 256))
         return;
 
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        switch (tile_element_get_type(mapElement)) {
+        switch (tile_element_get_type(tileElement)) {
         case TILE_ELEMENT_TYPE_SURFACE:
-            if (gRideRatingsCalcData.proximity_base_height <= inputMapElement->base_height) {
-                if (inputMapElement->clearance_height <= mapElement->base_height) {
+            if (gRideRatingsCalcData.proximity_base_height <= inputTileElement->base_height) {
+                if (inputTileElement->clearance_height <= tileElement->base_height) {
                     proximity_score_increment(PROXIMITY_SURFACE_SIDE_CLOSE);
                 }
             }
             break;
         case TILE_ELEMENT_TYPE_PATH:
-            if (abs((sint32)inputMapElement->base_height - (sint32)mapElement->base_height) <= 2) {
+            if (abs((sint32)inputTileElement->base_height - (sint32)tileElement->base_height) <= 2) {
                 proximity_score_increment(PROXIMITY_PATH_SIDE_CLOSE);
             }
             break;
         case TILE_ELEMENT_TYPE_TRACK:
-            if (inputMapElement->properties.track.ride_index != mapElement->properties.track.ride_index) {
-                if (abs((sint32)inputMapElement->base_height - (sint32)mapElement->base_height) <= 2) {
+            if (inputTileElement->properties.track.ride_index != tileElement->properties.track.ride_index) {
+                if (abs((sint32)inputTileElement->base_height - (sint32)tileElement->base_height) <= 2) {
                     proximity_score_increment(PROXIMITY_FOREIGN_TRACK_SIDE_CLOSE);
                 }
             }
             break;
         case TILE_ELEMENT_TYPE_SCENERY:
         case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
-            if (mapElement->base_height < inputMapElement->clearance_height) {
-                if (inputMapElement->base_height > mapElement->clearance_height) {
+            if (tileElement->base_height < inputTileElement->clearance_height) {
+                if (inputTileElement->base_height > tileElement->clearance_height) {
                     proximity_score_increment(PROXIMITY_SCENERY_SIDE_ABOVE);
                 } else {
                     proximity_score_increment(PROXIMITY_SCENERY_SIDE_BELOW);
@@ -417,18 +417,18 @@ static void ride_ratings_score_close_proximity_in_direction(rct_tile_element *in
             }
             break;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
 }
 
-static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *inputMapElement, sint32 x, sint32 y)
+static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *inputTileElement, sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        switch (tile_element_get_type(mapElement)) {
+        switch (tile_element_get_type(tileElement)) {
         case TILE_ELEMENT_TYPE_PATH:
         {
-            sint32 zDiff = (sint32)mapElement->base_height - (sint32)inputMapElement->base_height;
+            sint32 zDiff = (sint32)tileElement->base_height - (sint32)inputTileElement->base_height;
             if (zDiff >= 0 && zDiff <= 16)
             {
                 proximity_score_increment(PROXIMITY_PATH_TROUGH_VERTICAL_LOOP);
@@ -437,16 +437,16 @@ static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *in
 
         case TILE_ELEMENT_TYPE_TRACK:
         {
-            sint32 unk = (mapElement->type ^ inputMapElement->type) & 1;
+            sint32 unk = (tileElement->type ^ inputTileElement->type) & 1;
             if (unk != 0)
             {
-                sint32 zDiff = (sint32)mapElement->base_height - (sint32)inputMapElement->base_height;
+                sint32 zDiff = (sint32)tileElement->base_height - (sint32)inputTileElement->base_height;
                 if (zDiff >= 0 && zDiff <= 16)
                 {
                     proximity_score_increment(PROXIMITY_TRACK_THROUGH_VERTICAL_LOOP);
                     if (
-                        mapElement->properties.track.type == TRACK_ELEM_LEFT_VERTICAL_LOOP ||
-                        mapElement->properties.track.type == TRACK_ELEM_RIGHT_VERTICAL_LOOP
+                        tileElement->properties.track.type == TRACK_ELEM_LEFT_VERTICAL_LOOP ||
+                        tileElement->properties.track.type == TRACK_ELEM_RIGHT_VERTICAL_LOOP
                         )
                     {
                         proximity_score_increment(PROXIMITY_INTERSECTING_VERTICAL_LOOP);
@@ -455,25 +455,25 @@ static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *in
             }
         } break;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 }
 
 /**
  *
  *  rct2: 0x006B62DA
  */
-static void ride_ratings_score_close_proximity_loops(rct_tile_element *inputMapElement)
+static void ride_ratings_score_close_proximity_loops(rct_tile_element *inputTileElement)
 {
-    sint32 trackType = inputMapElement->properties.track.type;
+    sint32 trackType = inputTileElement->properties.track.type;
     if (trackType == TRACK_ELEM_LEFT_VERTICAL_LOOP || trackType == TRACK_ELEM_RIGHT_VERTICAL_LOOP) {
         sint32 x = gRideRatingsCalcData.proximity_x;
         sint32 y = gRideRatingsCalcData.proximity_y;
-        ride_ratings_score_close_proximity_loops_helper(inputMapElement, x, y);
+        ride_ratings_score_close_proximity_loops_helper(inputTileElement, x, y);
 
-        sint32 direction = tile_element_get_direction(inputMapElement);
+        sint32 direction = tile_element_get_direction(inputTileElement);
         x = gRideRatingsCalcData.proximity_x + TileDirectionDelta[direction].x;
         y = gRideRatingsCalcData.proximity_y + TileDirectionDelta[direction].y;
-        ride_ratings_score_close_proximity_loops_helper(inputMapElement, x, y);
+        ride_ratings_score_close_proximity_loops_helper(inputTileElement, x, y);
     }
 }
 
@@ -481,7 +481,7 @@ static void ride_ratings_score_close_proximity_loops(rct_tile_element *inputMapE
  *
  *  rct2: 0x006B5F9D
  */
-static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement)
+static void ride_ratings_score_close_proximity(rct_tile_element *inputTileElement)
 {
     if (gRideRatingsCalcData.station_flags & RIDE_RATING_STATION_FLAG_NO_ENTRANCE) {
         return;
@@ -490,15 +490,15 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement
     gRideRatingsCalcData.proximity_total++;
     sint32 x = gRideRatingsCalcData.proximity_x;
     sint32 y = gRideRatingsCalcData.proximity_y;
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        switch (tile_element_get_type(mapElement)) {
+        switch (tile_element_get_type(tileElement)) {
         case TILE_ELEMENT_TYPE_SURFACE:
-            gRideRatingsCalcData.proximity_base_height = mapElement->base_height;
-            if (mapElement->base_height * 8 == gRideRatingsCalcData.proximity_z) {
+            gRideRatingsCalcData.proximity_base_height = tileElement->base_height;
+            if (tileElement->base_height * 8 == gRideRatingsCalcData.proximity_z) {
                 proximity_score_increment(PROXIMITY_SURFACE_TOUCH);
             }
-            sint32 waterHeight = map_get_water_height(mapElement);
+            sint32 waterHeight = map_get_water_height(tileElement);
             if (waterHeight != 0) {
                 sint32 z = waterHeight * 16;
                 if (z <= gRideRatingsCalcData.proximity_z) {
@@ -518,69 +518,69 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement
             }
             break;
         case TILE_ELEMENT_TYPE_PATH:
-            if (mapElement->properties.path.type & 0xF0) {
-                if (mapElement->clearance_height == inputMapElement->base_height) {
+            if (tileElement->properties.path.type & 0xF0) {
+                if (tileElement->clearance_height == inputTileElement->base_height) {
                     proximity_score_increment(PROXIMITY_138B5A6);
                 }
-                if (mapElement->base_height == inputMapElement->clearance_height) {
+                if (tileElement->base_height == inputTileElement->clearance_height) {
                     proximity_score_increment(PROXIMITY_138B5A8);
                 }
             } else {
-                if (mapElement->clearance_height <= inputMapElement->base_height) {
+                if (tileElement->clearance_height <= inputTileElement->base_height) {
                     proximity_score_increment(PROXIMITY_PATH_OVER);
                 }
-                if (mapElement->clearance_height == inputMapElement->base_height) {
+                if (tileElement->clearance_height == inputTileElement->base_height) {
                     proximity_score_increment(PROXIMITY_PATH_TOUCH_ABOVE);
                 }
-                if (mapElement->base_height == inputMapElement->clearance_height) {
+                if (tileElement->base_height == inputTileElement->clearance_height) {
                     proximity_score_increment(PROXIMITY_PATH_TOUCH_UNDER);
                 }
             }
             break;
         case TILE_ELEMENT_TYPE_TRACK:
         {
-            sint32 trackType = mapElement->properties.track.type;
+            sint32 trackType = tileElement->properties.track.type;
             if (trackType == TRACK_ELEM_LEFT_VERTICAL_LOOP || trackType == TRACK_ELEM_RIGHT_VERTICAL_LOOP) {
-                sint32 sequence = tile_element_get_track_sequence(mapElement);
+                sint32 sequence = tile_element_get_track_sequence(tileElement);
                 if (sequence == 3 || sequence == 6) {
-                    if (mapElement->base_height - inputMapElement->clearance_height <= 10) {
+                    if (tileElement->base_height - inputTileElement->clearance_height <= 10) {
                         proximity_score_increment(PROXIMITY_THROUGH_VERTICAL_LOOP);
                     }
                 }
             }
-            if (inputMapElement->properties.track.ride_index != mapElement->properties.track.ride_index) {
+            if (inputTileElement->properties.track.ride_index != tileElement->properties.track.ride_index) {
                 proximity_score_increment(PROXIMITY_FOREIGN_TRACK_ABOVE_OR_BELOW);
-                if (mapElement->clearance_height == inputMapElement->base_height) {
+                if (tileElement->clearance_height == inputTileElement->base_height) {
                     proximity_score_increment(PROXIMITY_FOREIGN_TRACK_TOUCH_ABOVE);
                 }
-                if (mapElement->clearance_height + 2 <= inputMapElement->base_height) {
-                    if (mapElement->clearance_height + 10 >= inputMapElement->base_height) {
+                if (tileElement->clearance_height + 2 <= inputTileElement->base_height) {
+                    if (tileElement->clearance_height + 10 >= inputTileElement->base_height) {
                         proximity_score_increment(PROXIMITY_FOREIGN_TRACK_CLOSE_ABOVE);
                     }
                 }
-                if (inputMapElement->clearance_height == mapElement->base_height) {
+                if (inputTileElement->clearance_height == tileElement->base_height) {
                     proximity_score_increment(PROXIMITY_FOREIGN_TRACK_TOUCH_ABOVE);
                 }
-                if (inputMapElement->clearance_height + 2 == mapElement->base_height) {
-                    if ((uint8)(inputMapElement->clearance_height + 10) >= mapElement->base_height) {
+                if (inputTileElement->clearance_height + 2 == tileElement->base_height) {
+                    if ((uint8)(inputTileElement->clearance_height + 10) >= tileElement->base_height) {
                         proximity_score_increment(PROXIMITY_FOREIGN_TRACK_CLOSE_ABOVE);
                     }
                 }
             } else {
-                trackType = mapElement->properties.track.type;
+                trackType = tileElement->properties.track.type;
                 bool isStation = (
                     trackType == TRACK_ELEM_END_STATION ||
                     trackType == TRACK_ELEM_MIDDLE_STATION ||
                     trackType == TRACK_ELEM_BEGIN_STATION
                 );
-                if (mapElement->clearance_height == inputMapElement->base_height) {
+                if (tileElement->clearance_height == inputTileElement->base_height) {
                     proximity_score_increment(PROXIMITY_OWN_TRACK_TOUCH_ABOVE);
                     if (isStation) {
                         proximity_score_increment(PROXIMITY_OWN_STATION_TOUCH_ABOVE);
                     }
                 }
-                if (mapElement->clearance_height + 2 <= inputMapElement->base_height) {
-                    if (mapElement->clearance_height + 10 >= inputMapElement->base_height) {
+                if (tileElement->clearance_height + 2 <= inputTileElement->base_height) {
+                    if (tileElement->clearance_height + 10 >= inputTileElement->base_height) {
                         proximity_score_increment(PROXIMITY_OWN_TRACK_CLOSE_ABOVE);
                         if (isStation) {
                             proximity_score_increment(PROXIMITY_OWN_STATION_CLOSE_ABOVE);
@@ -588,14 +588,14 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement
                     }
                 }
 
-                if (inputMapElement->clearance_height == mapElement->base_height) {
+                if (inputTileElement->clearance_height == tileElement->base_height) {
                     proximity_score_increment(PROXIMITY_OWN_TRACK_TOUCH_ABOVE);
                     if (isStation) {
                         proximity_score_increment(PROXIMITY_OWN_STATION_TOUCH_ABOVE);
                     }
                 }
-                if (inputMapElement->clearance_height + 2 <= mapElement->base_height) {
-                    if (inputMapElement->clearance_height + 10 >= mapElement->base_height) {
+                if (inputTileElement->clearance_height + 2 <= tileElement->base_height) {
+                    if (inputTileElement->clearance_height + 10 >= tileElement->base_height) {
                         proximity_score_increment(PROXIMITY_OWN_TRACK_CLOSE_ABOVE);
                         if (isStation) {
                             proximity_score_increment(PROXIMITY_OWN_STATION_CLOSE_ABOVE);
@@ -605,12 +605,12 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputMapElement
             }
         } break;
         } // switch tile_element_get_type
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
-    uint8 direction = tile_element_get_direction(inputMapElement);
-    ride_ratings_score_close_proximity_in_direction(inputMapElement, (direction + 1) & 3);
-    ride_ratings_score_close_proximity_in_direction(inputMapElement, (direction - 1) & 3);
-    ride_ratings_score_close_proximity_loops(inputMapElement);
+    uint8 direction = tile_element_get_direction(inputTileElement);
+    ride_ratings_score_close_proximity_in_direction(inputTileElement, (direction + 1) & 3);
+    ride_ratings_score_close_proximity_in_direction(inputTileElement, (direction - 1) & 3);
+    ride_ratings_score_close_proximity_loops(inputTileElement);
 
     switch (gRideRatingsCalcData.proximity_track_type) {
     case TRACK_ELEM_BRAKES:
@@ -1291,15 +1291,15 @@ static sint32 ride_ratings_get_scenery_score(Ride *ride)
     for (sint32 yy = max(y - 5, 0); yy <= min(y + 5, 255); yy++) {
         for (sint32 xx = max(x - 5, 0); xx <= min(x + 5, 255); xx++) {
             // Count scenery items on this tile
-            rct_tile_element *mapElement = map_get_first_element_at(xx, yy);
+            rct_tile_element *tileElement = map_get_first_element_at(xx, yy);
             do {
-                if (mapElement->flags & (1 << 4))
+                if (tileElement->flags & (1 << 4))
                     continue;
 
-                sint32 type = tile_element_get_type(mapElement);
+                sint32 type = tile_element_get_type(tileElement);
                 if (type == TILE_ELEMENT_TYPE_SCENERY || type == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
                     numSceneryItems++;
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
         }
     }
 
diff --git a/src/openrct2/ride/shops/Facility.cpp b/src/openrct2/ride/shops/Facility.cpp
index 61a0baf279..527938a5a9 100644
--- a/src/openrct2/ride/shops/Facility.cpp
+++ b/src/openrct2/ride/shops/Facility.cpp
@@ -30,7 +30,7 @@
  *  rct2: 0x007630DE
  */
 static void facility_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     bool hasSupports = wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_3], NULL);
 
diff --git a/src/openrct2/ride/shops/Shop.cpp b/src/openrct2/ride/shops/Shop.cpp
index cef5fc28d0..1fbf11abba 100644
--- a/src/openrct2/ride/shops/Shop.cpp
+++ b/src/openrct2/ride/shops/Shop.cpp
@@ -30,7 +30,7 @@
  *  rct2: 0x007617A5
  */
 static void shop_paint_setup(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                             rct_tile_element * mapElement)
+                             rct_tile_element * tileElement)
 {
     bool hasSupports = wooden_a_supports_paint_setup(session, direction & 1, 0, height, session->TrackColours[SCHEME_3], NULL);
 
diff --git a/src/openrct2/ride/thrill/3dCinema.cpp b/src/openrct2/ride/thrill/3dCinema.cpp
index 064b3e1e29..157f3cf728 100644
--- a/src/openrct2/ride/thrill/3dCinema.cpp
+++ b/src/openrct2/ride/thrill/3dCinema.cpp
@@ -26,7 +26,7 @@
 static void paint_3d_cinema_structure(paint_session * session, uint8 rideIndex, uint8 direction, sint8 xOffset, sint8 yOffset,
                                       uint16 height)
 {
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     Ride *           ride      = get_ride(rideIndex);
     rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
@@ -53,7 +53,7 @@ static void paint_3d_cinema_structure(paint_session * session, uint8 rideIndex,
     sub_98197C(session, imageId, xOffset, yOffset, 24, 24, 47, height + 3, xOffset + 16, yOffset + 16, height + 3,
                get_current_rotation());
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
@@ -61,7 +61,7 @@ static void paint_3d_cinema_structure(paint_session * session, uint8 rideIndex,
  * rct2: 0x0076574C
  */
 static void paint_3d_cinema(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                            rct_tile_element * mapElement)
+                            rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -74,7 +74,7 @@ static void paint_3d_cinema(paint_session * session, uint8 rideIndex, uint8 trac
     track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
                                  get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
                                   fenceSpritesRope, get_current_rotation());
 
     switch (trackSequence)
diff --git a/src/openrct2/ride/thrill/Enterprise.cpp b/src/openrct2/ride/thrill/Enterprise.cpp
index e76ac4cb2c..22625dc907 100644
--- a/src/openrct2/ride/thrill/Enterprise.cpp
+++ b/src/openrct2/ride/thrill/Enterprise.cpp
@@ -23,11 +23,11 @@
 
 /** rct2: 0x008A2ABC */
 static void paint_enterprise_structure(paint_session * session, Ride * ride, sint8 xOffset, sint8 yOffset, uint16 height,
-                                       rct_tile_element * mapElement)
+                                       rct_tile_element * tileElement)
 {
     height += 7;
 
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
     rct_ride_entry *  rideEntry       = get_ride_entry(ride->subtype);
     rct_vehicle *     vehicle         = NULL;
 
@@ -45,7 +45,7 @@ static void paint_enterprise_structure(paint_session * session, Ride * ride, sin
         session->CurrentlyDrawnItem = vehicle;
     }
 
-    uint32 imageOffset = tile_element_get_direction_with_offset(mapElement, get_current_rotation());
+    uint32 imageOffset = tile_element_get_direction_with_offset(tileElement, get_current_rotation());
     if (vehicle != NULL)
     {
         imageOffset = (vehicle->vehicle_sprite_type << 2) + (((vehicle->sprite_direction >> 3) + get_current_rotation()) % 4);
@@ -79,13 +79,13 @@ static void paint_enterprise_structure(paint_session * session, Ride * ride, sin
         }
     }
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
 /** rct2: 0x008A1584 */
 static void paint_enterprise(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                             rct_tile_element * mapElement)
+                             rct_tile_element * tileElement)
 {
     trackSequence = track_map_4x4[direction][trackSequence];
 
@@ -98,48 +98,48 @@ static void paint_enterprise(paint_session * session, uint8 rideIndex, uint8 tra
     track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
                                  get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
                                   fenceSpritesRope, get_current_rotation());
 
     switch (trackSequence)
     {
     case 5:
-        paint_enterprise_structure(session, ride, 16, 16, height, mapElement);
+        paint_enterprise_structure(session, ride, 16, 16, height, tileElement);
         break;
     case 6:
-        paint_enterprise_structure(session, ride, 16, -16, height, mapElement);
+        paint_enterprise_structure(session, ride, 16, -16, height, tileElement);
         break;
     case 10:
-        paint_enterprise_structure(session, ride, -16, -16, height, mapElement);
+        paint_enterprise_structure(session, ride, -16, -16, height, tileElement);
         break;
     case 9:
-        paint_enterprise_structure(session, ride, -16, 16, height, mapElement);
+        paint_enterprise_structure(session, ride, -16, 16, height, tileElement);
         break;
 
     case 0:
-        paint_enterprise_structure(session, ride, 48, 48, height, mapElement);
+        paint_enterprise_structure(session, ride, 48, 48, height, tileElement);
         break;
     case 3:
-        paint_enterprise_structure(session, ride, 48, -48, height, mapElement);
+        paint_enterprise_structure(session, ride, 48, -48, height, tileElement);
         break;
     case 15:
-        paint_enterprise_structure(session, ride, -48, -48, height, mapElement);
+        paint_enterprise_structure(session, ride, -48, -48, height, tileElement);
         break;
     case 12:
-        paint_enterprise_structure(session, ride, -48, 48, height, mapElement);
+        paint_enterprise_structure(session, ride, -48, 48, height, tileElement);
         break;
 
     case 7:
-        paint_enterprise_structure(session, ride, 16, -48, height, mapElement);
+        paint_enterprise_structure(session, ride, 16, -48, height, tileElement);
         break;
     case 11:
-        paint_enterprise_structure(session, ride, -16, -48, height, mapElement);
+        paint_enterprise_structure(session, ride, -16, -48, height, tileElement);
         break;
     case 14:
-        paint_enterprise_structure(session, ride, -48, -16, height, mapElement);
+        paint_enterprise_structure(session, ride, -48, -16, height, tileElement);
         break;
     case 13:
-        paint_enterprise_structure(session, ride, -48, 16, height, mapElement);
+        paint_enterprise_structure(session, ride, -48, 16, height, tileElement);
         break;
     }
 
diff --git a/src/openrct2/ride/thrill/GoKarts.cpp b/src/openrct2/ride/thrill/GoKarts.cpp
index 57d22968de..a8d522c2bb 100644
--- a/src/openrct2/ride/thrill/GoKarts.cpp
+++ b/src/openrct2/ride/thrill/GoKarts.cpp
@@ -132,7 +132,7 @@ static const uint32 go_karts_track_pieces_25_deg_up_to_flat[4][2] = {
 
 /** rct2: 0x0074A748 */
 static void paint_go_karts_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
     if (direction == 0 || direction == 2)
@@ -164,7 +164,7 @@ static void paint_go_karts_track_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x0074A758 */
 static void paint_go_karts_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     uint32         imageId;
     paint_struct * ps;
@@ -217,7 +217,7 @@ static void paint_go_karts_track_25_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x0074A768 */
 static void paint_go_karts_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32         imageId;
     paint_struct * ps;
@@ -270,7 +270,7 @@ static void paint_go_karts_track_flat_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x */
 static void paint_go_karts_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32         imageId;
     paint_struct * ps;
@@ -323,28 +323,28 @@ static void paint_go_karts_track_25_deg_up_to_flat(paint_session * session, uint
 
 /** rct2: 0x0074A788 */
 static void paint_go_karts_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    paint_go_karts_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_go_karts_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x0074A798 */
 static void paint_go_karts_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_go_karts_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_go_karts_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x0074A7A8 */
 static void paint_go_karts_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_go_karts_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_go_karts_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x */
 static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16                             position      = session->MapPosition;
     Ride *                               ride          = get_ride(rideIndex);
@@ -354,7 +354,7 @@ static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uin
     uint32 imageId;
     const uint32(*sprites)[2] = go_karts_track_pieces_starting_grid;
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
         sprites = go_karts_track_pieces_starting_grid_end;
     }
@@ -371,12 +371,12 @@ static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uin
 
     if (direction == 0 || direction == 2)
     {
-        hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_NW, hasFence, entranceStyle, direction, height);
     }
     else
     {
-        hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_NE, hasFence, entranceStyle, direction, height);
     }
 
@@ -396,18 +396,18 @@ static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uin
 
     if (direction == 0 || direction == 2)
     {
-        hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_SE, hasFence, entranceStyle, direction, height);
     }
     else
     {
-        hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_SW, hasFence, entranceStyle, direction, height);
     }
 
-    if (mapElement->properties.track.type == TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type == TRACK_ELEM_END_STATION)
     {
-        const bool hasGreenLight = tile_element_get_green_light(mapElement);
+        const bool hasGreenLight = tile_element_get_green_light(tileElement);
 
         switch (direction)
         {
@@ -454,7 +454,7 @@ static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x0074A7E8 */
 static void paint_go_karts_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -523,9 +523,9 @@ static void paint_go_karts_track_left_quarter_turn_1_tile(paint_session * sessio
 
 /** rct2: 0x0074A7F8 */
 static void paint_go_karts_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_go_karts_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
+    paint_go_karts_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 /**
diff --git a/src/openrct2/ride/thrill/LaunchedFreefall.cpp b/src/openrct2/ride/thrill/LaunchedFreefall.cpp
index 37fbfb3a9d..a84c01716a 100644
--- a/src/openrct2/ride/thrill/LaunchedFreefall.cpp
+++ b/src/openrct2/ride/thrill/LaunchedFreefall.cpp
@@ -92,7 +92,7 @@ void vehicle_visual_launched_freefall(paint_session * session, sint32 x, sint32
 
 /** rct2: 0x006FD1F8 */
 static void paint_launched_freefall_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -105,7 +105,7 @@ static void paint_launched_freefall_base(paint_session * session, uint8 rideInde
     uint32 imageId = SPR_FLOOR_METAL | session->TrackColours[SCHEME_SUPPORTS];
     sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
                                   launched_freefall_fence_sprites, get_current_rotation());
 
     if (trackSequence == 0)
@@ -164,7 +164,7 @@ static void paint_launched_freefall_base(paint_session * session, uint8 rideInde
 
 /** rct2: 0x006FD208 */
 static void paint_launched_freefall_tower_section(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence == 1)
     {
@@ -174,8 +174,8 @@ static void paint_launched_freefall_tower_section(paint_session * session, uint8
     uint32 imageId = SPR_LAUNCHED_FREEFALL_TOWER_SEGMENT | session->TrackColours[SCHEME_TRACK];
     sub_98197C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
 
-    rct_tile_element * nextMapElement = mapElement + 1;
-    if (tile_element_is_last_for_tile(mapElement) || mapElement->clearance_height != nextMapElement->base_height)
+    rct_tile_element * nextTileElement = tileElement + 1;
+    if (tile_element_is_last_for_tile(tileElement) || tileElement->clearance_height != nextTileElement->base_height)
     {
         imageId = SPR_LAUNCHED_FREEFALL_TOWER_SEGMENT_TOP | session->TrackColours[SCHEME_TRACK];
         sub_98199C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
diff --git a/src/openrct2/ride/thrill/MagicCarpet.cpp b/src/openrct2/ride/thrill/MagicCarpet.cpp
index 21b492e132..24b2d9433f 100644
--- a/src/openrct2/ride/thrill/MagicCarpet.cpp
+++ b/src/openrct2/ride/thrill/MagicCarpet.cpp
@@ -174,7 +174,7 @@ static void paint_magic_carpet_vehicle(paint_session * session, Ride * ride, uin
 /** rct2: 0x00899104 */
 static void paint_magic_carpet_structure(paint_session * session, Ride * ride, uint8 direction, sint8 axisOffset, uint16 height)
 {
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
     rct_vehicle *     vehicle         = get_first_vehicle(ride);
 
     uint32 swingImageId = 0;
@@ -204,12 +204,12 @@ static void paint_magic_carpet_structure(paint_session * session, Ride * ride, u
     paint_magic_carpet_frame(session, PLANE_FRONT, direction, offset, bbOffset, bbSize);
 
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
 }
 
 /** rct2: 0x00898514 */
 static void paint_magic_carpet(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                               rct_tile_element * mapElement)
+                               rct_tile_element * tileElement)
 {
     uint8 relativeTrackSequence = track_map_1x4[direction][trackSequence];
 
diff --git a/src/openrct2/ride/thrill/MotionSimulator.cpp b/src/openrct2/ride/thrill/MotionSimulator.cpp
index 1c878ec8e8..437aad88a5 100644
--- a/src/openrct2/ride/thrill/MotionSimulator.cpp
+++ b/src/openrct2/ride/thrill/MotionSimulator.cpp
@@ -37,12 +37,12 @@ enum
  *  rct2: 0x0076522A
  */
 static void paint_motionsimulator_vehicle(paint_session * session, sint8 offsetX, sint8 offsetY, uint8 direction, sint32 height,
-                                          rct_tile_element * mapElement)
+                                          rct_tile_element * tileElement)
 {
-    Ride *           ride      = get_ride(mapElement->properties.track.ride_index);
+    Ride *           ride      = get_ride(tileElement->properties.track.ride_index);
     rct_ride_entry * rideEntry = get_ride_entry_by_ride(ride);
 
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     rct_vehicle * vehicle = NULL;
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)
@@ -128,13 +128,13 @@ static void paint_motionsimulator_vehicle(paint_session * session, sint8 offsetX
         break;
     }
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
 /** rct2: 0x008A85C4 */
 static void paint_motionsimulator(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                  rct_tile_element * mapElement)
+                                  rct_tile_element * tileElement)
 {
     trackSequence = track_map_2x2[direction][trackSequence];
 
@@ -145,19 +145,19 @@ static void paint_motionsimulator(paint_session * session, uint8 rideIndex, uint
     wooden_a_supports_paint_setup(session, (direction & 1), 0, height, session->TrackColours[SCHEME_MISC], NULL);
     track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
                                  get_current_rotation());
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_SUPPORTS], height,
                                   fenceSpritesRope, get_current_rotation());
 
     switch (trackSequence)
     {
     case 1:
-        paint_motionsimulator_vehicle(session, 16, -16, direction, height, mapElement);
+        paint_motionsimulator_vehicle(session, 16, -16, direction, height, tileElement);
         break;
     case 2:
-        paint_motionsimulator_vehicle(session, -16, 16, direction, height, mapElement);
+        paint_motionsimulator_vehicle(session, -16, 16, direction, height, tileElement);
         break;
     case 3:
-        paint_motionsimulator_vehicle(session, -16, -16, direction, height, mapElement);
+        paint_motionsimulator_vehicle(session, -16, -16, direction, height, tileElement);
         break;
     }
 
diff --git a/src/openrct2/ride/thrill/PirateShip.cpp b/src/openrct2/ride/thrill/PirateShip.cpp
index bd6d93fb5d..32f994c5db 100644
--- a/src/openrct2/ride/thrill/PirateShip.cpp
+++ b/src/openrct2/ride/thrill/PirateShip.cpp
@@ -65,7 +65,7 @@ static void paint_pirate_ship_structure(paint_session * session, Ride * ride, ui
 {
     uint32 imageId, baseImageId;
 
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
     rct_vehicle *    vehicle  = NULL;
@@ -162,13 +162,13 @@ static void paint_pirate_ship_structure(paint_session * session, Ride * ride, ui
     sub_98199C(session, imageId, xOffset, yOffset, bounds.length_x, bounds.length_y, 80, height, bounds.offset_x,
                bounds.offset_y, height, get_current_rotation());
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
 /** rct2: 0x008A85C4 */
 static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                              rct_tile_element * mapElement)
+                              rct_tile_element * tileElement)
 {
     uint8    relativeTrackSequence = track_map_1x5[direction][trackSequence];
     Ride *   ride                  = get_ride(rideIndex);
@@ -204,7 +204,7 @@ static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 tr
     {
         if (relativeTrackSequence != 1 && relativeTrackSequence != 4)
         {
-            hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
+            hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
             if (relativeTrackSequence == 2)
             {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_BEGIN_FENCED_NW_SE : SPR_STATION_PLATFORM_BEGIN_NW_SE) |
@@ -221,7 +221,7 @@ static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 tr
                       session->TrackColours[SCHEME_TRACK];
             sub_98196C(session, imageId, 24, 0, 8, 32, 1, height + 9, get_current_rotation());
 
-            hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
+            hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
             if (relativeTrackSequence == 3)
             {
                 if (hasFence)
@@ -249,7 +249,7 @@ static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 tr
     {
         if (relativeTrackSequence != 1 && relativeTrackSequence != 4)
         {
-            hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
+            hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
             if (relativeTrackSequence == 2)
             {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_BEGIN_FENCED_SW_NE : SPR_STATION_PLATFORM_BEGIN_SW_NE) |
@@ -266,7 +266,7 @@ static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 tr
                       session->TrackColours[SCHEME_TRACK];
             sub_98196C(session, imageId, 0, 24, 32, 8, 1, height + 9, get_current_rotation());
 
-            hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
+            hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
             if (relativeTrackSequence == 3)
             {
                 if (hasFence)
diff --git a/src/openrct2/ride/thrill/RotoDrop.cpp b/src/openrct2/ride/thrill/RotoDrop.cpp
index 6e6092b504..c4acd20e00 100644
--- a/src/openrct2/ride/thrill/RotoDrop.cpp
+++ b/src/openrct2/ride/thrill/RotoDrop.cpp
@@ -92,7 +92,7 @@ void vehicle_visual_roto_drop(paint_session * session, sint32 x, sint32 imageDir
 
 /** rct2: 0x00886194 */
 static void paint_roto_drop_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -105,7 +105,7 @@ static void paint_roto_drop_base(paint_session * session, uint8 rideIndex, uint8
     uint32 imageId = SPR_FLOOR_METAL_B | session->TrackColours[SCHEME_SUPPORTS];
     sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
                                   fenceSpritesMetalB, get_current_rotation());
 
     if (trackSequence == 0)
@@ -169,7 +169,7 @@ static void paint_roto_drop_base(paint_session * session, uint8 rideIndex, uint8
 
 /** rct2: 0x008861A4 */
 static void paint_roto_drop_tower_section(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence == 1)
     {
@@ -179,8 +179,8 @@ static void paint_roto_drop_tower_section(paint_session * session, uint8 rideInd
     uint32 imageId = SPR_ROTO_DROP_TOWER_SEGMENT | session->TrackColours[SCHEME_TRACK];
     sub_98197C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
 
-    rct_tile_element * nextMapElement = mapElement + 1;
-    if (tile_element_is_last_for_tile(mapElement) || mapElement->clearance_height != nextMapElement->base_height)
+    rct_tile_element * nextTileElement = tileElement + 1;
+    if (tile_element_is_last_for_tile(tileElement) || tileElement->clearance_height != nextTileElement->base_height)
     {
         imageId = SPR_ROTO_DROP_TOWER_SEGMENT_TOP | session->TrackColours[SCHEME_TRACK];
         sub_98199C(session, imageId, 0, 0, 2, 2, 30, height, 8, 8, height, get_current_rotation());
diff --git a/src/openrct2/ride/thrill/SwingingInverterShip.cpp b/src/openrct2/ride/thrill/SwingingInverterShip.cpp
index d500e2b594..9013a8c931 100644
--- a/src/openrct2/ride/thrill/SwingingInverterShip.cpp
+++ b/src/openrct2/ride/thrill/SwingingInverterShip.cpp
@@ -55,7 +55,7 @@ static const uint32 swinging_inverter_ship_frame_sprites[] = { SPR_SWINGING_INVE
 static void paint_swinging_inverter_ship_structure(paint_session * session, Ride * ride, uint8 direction, sint8 axisOffset,
                                                    uint16 height)
 {
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
     rct_vehicle *    vehicle  = NULL;
@@ -118,13 +118,13 @@ static void paint_swinging_inverter_ship_structure(paint_session * session, Ride
                    boundBox.offset_x, boundBox.offset_y, height, get_current_rotation());
     }
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
 /** rct2: 0x00760260 */
 static void paint_swinging_inverter_ship(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     uint8 relativeTrackSequence = track_map_1x4[direction][trackSequence];
 
diff --git a/src/openrct2/ride/thrill/TopSpin.cpp b/src/openrct2/ride/thrill/TopSpin.cpp
index e9931ec2d8..5cd8bea5ed 100644
--- a/src/openrct2/ride/thrill/TopSpin.cpp
+++ b/src/openrct2/ride/thrill/TopSpin.cpp
@@ -48,12 +48,12 @@ static sint8 TopSpinSeatPositionOffset[] = {
  *  rct2: 0x0076750D
  */
 static void top_spin_paint_vehicle(paint_session * session, sint8 al, sint8 cl, uint8 rideIndex, uint8 direction, sint32 height,
-                                   rct_tile_element * mapElement)
+                                   rct_tile_element * tileElement)
 {
     uint16 boundBoxOffsetX, boundBoxOffsetY, boundBoxOffsetZ;
-    // As we will be drawing a vehicle we need to backup the mapElement that
+    // As we will be drawing a vehicle we need to backup the tileElement that
     // is assigned to the drawings.
-    rct_tile_element * curMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * curTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     height += 3;
 
@@ -240,7 +240,7 @@ static void top_spin_paint_vehicle(paint_session * session, sint8 al, sint8 cl,
     sub_98199C(session, image_id, al, cl, lengthX, lengthY, 90, height, boundBoxOffsetX, boundBoxOffsetY, boundBoxOffsetZ,
                rotation);
 
-    session->CurrentlyDrawnItem = curMapElement;
+    session->CurrentlyDrawnItem = curTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
@@ -248,7 +248,7 @@ static void top_spin_paint_vehicle(paint_session * session, sint8 al, sint8 cl,
  * rct2: 0x0076679C
  */
 static void paint_top_spin(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                           rct_tile_element * mapElement)
+                           rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -261,28 +261,28 @@ static void paint_top_spin(paint_session * session, uint8 rideIndex, uint8 track
     track_paint_util_paint_floor(session, edges, session->TrackColours[SCHEME_TRACK], height, floorSpritesCork,
                                  get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
                                   fenceSpritesRope, get_current_rotation());
 
     switch (trackSequence)
     {
     case 1:
-        top_spin_paint_vehicle(session, 32, 32, rideIndex, direction, height, mapElement);
+        top_spin_paint_vehicle(session, 32, 32, rideIndex, direction, height, tileElement);
         break;
     case 3:
-        top_spin_paint_vehicle(session, 32, -32, rideIndex, direction, height, mapElement);
+        top_spin_paint_vehicle(session, 32, -32, rideIndex, direction, height, tileElement);
         break;
     case 5:
-        top_spin_paint_vehicle(session, 0, -32, rideIndex, direction, height, mapElement);
+        top_spin_paint_vehicle(session, 0, -32, rideIndex, direction, height, tileElement);
         break;
     case 6:
-        top_spin_paint_vehicle(session, -32, 32, rideIndex, direction, height, mapElement);
+        top_spin_paint_vehicle(session, -32, 32, rideIndex, direction, height, tileElement);
         break;
     case 7:
-        top_spin_paint_vehicle(session, -32, -32, rideIndex, direction, height, mapElement);
+        top_spin_paint_vehicle(session, -32, -32, rideIndex, direction, height, tileElement);
         break;
     case 8:
-        top_spin_paint_vehicle(session, -32, 0, rideIndex, direction, height, mapElement);
+        top_spin_paint_vehicle(session, -32, 0, rideIndex, direction, height, tileElement);
         break;
     }
 
diff --git a/src/openrct2/ride/thrill/Twist.cpp b/src/openrct2/ride/thrill/Twist.cpp
index 1a97bf2604..8b97f48055 100644
--- a/src/openrct2/ride/thrill/Twist.cpp
+++ b/src/openrct2/ride/thrill/Twist.cpp
@@ -25,7 +25,7 @@
 static void paint_twist_structure(paint_session * session, Ride * ride, uint8 direction, sint8 xOffset, sint8 yOffset,
                                   uint16 height)
 {
-    rct_tile_element * savedMapElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
+    rct_tile_element * savedTileElement = static_cast<rct_tile_element *>(session->CurrentlyDrawnItem);
 
     rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
     rct_vehicle *    vehicle   = NULL;
@@ -82,13 +82,13 @@ static void paint_twist_structure(paint_session * session, Ride * ride, uint8 di
         }
     }
 
-    session->CurrentlyDrawnItem = savedMapElement;
+    session->CurrentlyDrawnItem = savedTileElement;
     session->InteractionType    = VIEWPORT_INTERACTION_ITEM_RIDE;
 }
 
 /** rct2: 0x0076D858 */
 static void paint_twist(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                        rct_tile_element * mapElement)
+                        rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -106,19 +106,19 @@ static void paint_twist(paint_session * session, uint8 rideIndex, uint8 trackSeq
     switch (trackSequence)
     {
     case 7:
-        if (track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation()))
+        if (track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation()))
         {
             imageId = SPR_FENCE_ROPE_SW | session->TrackColours[SCHEME_MISC];
             sub_98197C(session, imageId, 0, 0, 1, 28, 7, height, 29, 0, height + 3, get_current_rotation());
         }
-        if (track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation()))
+        if (track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation()))
         {
             imageId = SPR_FENCE_ROPE_SE | session->TrackColours[SCHEME_MISC];
             sub_98197C(session, imageId, 0, 0, 28, 1, 7, height, 0, 29, height + 3, get_current_rotation());
         }
         break;
     default:
-        track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_MISC], height,
+        track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_MISC], height,
                                       fenceSpritesRope, get_current_rotation());
         break;
     }
diff --git a/src/openrct2/ride/track_design_save.c b/src/openrct2/ride/track_design_save.c
index 372986296c..a8968aa94f 100644
--- a/src/openrct2/ride/track_design_save.c
+++ b/src/openrct2/ride/track_design_save.c
@@ -37,23 +37,23 @@
 bool gTrackDesignSaveMode = false;
 uint8 gTrackDesignSaveRideIndex = 255;
 
-static size_t _trackSavedMapElementsCount;
+static size_t _trackSavedTileElementsCount;
 #ifdef NO_RCT2
-    static rct_tile_element *_trackSavedMapElements[TRACK_MAX_SAVED_TILE_ELEMENTS];
+    static rct_tile_element *_trackSavedTileElements[TRACK_MAX_SAVED_TILE_ELEMENTS];
 #else
-    static rct_tile_element **_trackSavedMapElements = (rct_tile_element**)0x00F63674;
+    static rct_tile_element **_trackSavedTileElements = (rct_tile_element**)0x00F63674;
 #endif
 
-static size_t _trackSavedMapElementsDescCount;
-static rct_td6_scenery_element _trackSavedMapElementsDesc[TRACK_MAX_SAVED_TILE_ELEMENTS];
+static size_t _trackSavedTileElementsDescCount;
+static rct_td6_scenery_element _trackSavedTileElementsDesc[TRACK_MAX_SAVED_TILE_ELEMENTS];
 
 static rct_track_td6 *_trackDesign;
 static uint8 _trackSaveDirection;
 
-static bool track_design_save_should_select_scenery_around(sint32 rideIndex, rct_tile_element *mapElement);
+static bool track_design_save_should_select_scenery_around(sint32 rideIndex, rct_tile_element *tileElement);
 static void track_design_save_select_nearby_scenery_for_tile(sint32 rideIndex, sint32 cx, sint32 cy);
-static bool track_design_save_add_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *mapElement);
-static void track_design_save_remove_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *mapElement);
+static bool track_design_save_add_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *tileElement);
+static void track_design_save_remove_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *tileElement);
 static bool track_design_save_copy_scenery_to_td6(rct_track_td6 *td6);
 static rct_track_td6 *track_design_save_to_td6(uint8 rideIndex);
 static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td6);
@@ -61,31 +61,31 @@ static bool track_design_save_to_td6_for_tracked_ride(uint8 rideIndex, rct_track
 
 void track_design_save_init()
 {
-    _trackSavedMapElementsCount = 0;
-    _trackSavedMapElementsDescCount = 0;
+    _trackSavedTileElementsCount = 0;
+    _trackSavedTileElementsDescCount = 0;
 
 #ifdef NO_RCT2
-    memset(_trackSavedMapElements, 0, sizeof(_trackSavedMapElements));
+    memset(_trackSavedTileElements, 0, sizeof(_trackSavedTileElements));
 #else
-    memset(_trackSavedMapElements, 0, sizeof(rct_tile_element*) * TRACK_MAX_SAVED_TILE_ELEMENTS);
+    memset(_trackSavedTileElements, 0, sizeof(rct_tile_element*) * TRACK_MAX_SAVED_TILE_ELEMENTS);
 #endif
 
-    memset(_trackSavedMapElementsDesc, 0, sizeof(_trackSavedMapElementsDesc));
+    memset(_trackSavedTileElementsDesc, 0, sizeof(_trackSavedTileElementsDesc));
 }
 
 /**
  *
  *  rct2: 0x006D2B07
  */
-void track_design_save_select_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *mapElement, bool collect)
+void track_design_save_select_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *tileElement, bool collect)
 {
-    if (track_design_save_contains_tile_element(mapElement)) {
+    if (track_design_save_contains_tile_element(tileElement)) {
         if (!collect) {
-            track_design_save_remove_tile_element(interactionType, x, y, mapElement);
+            track_design_save_remove_tile_element(interactionType, x, y, tileElement);
         }
     } else {
         if (collect) {
-            if (!track_design_save_add_tile_element(interactionType, x, y, mapElement)) {
+            if (!track_design_save_add_tile_element(interactionType, x, y, tileElement)) {
                 context_show_error(
                     STR_SAVE_TRACK_SCENERY_UNABLE_TO_SELECT_ADDITIONAL_ITEM_OF_SCENERY,
                     STR_SAVE_TRACK_SCENERY_TOO_MANY_ITEMS_SELECTED
@@ -101,17 +101,17 @@ void track_design_save_select_tile_element(sint32 interactionType, sint32 x, sin
  */
 void track_design_save_select_nearby_scenery(sint32 rideIndex)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     for (sint32 y = 0; y < 256; y++) {
         for (sint32 x = 0; x < 256; x++) {
-            mapElement = map_get_first_element_at(x, y);
+            tileElement = map_get_first_element_at(x, y);
             do {
-                if (track_design_save_should_select_scenery_around(rideIndex, mapElement)) {
+                if (track_design_save_should_select_scenery_around(rideIndex, tileElement)) {
                     track_design_save_select_nearby_scenery_for_tile(rideIndex, x, y);
                     break;
                 }
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
         }
     }
     gfx_invalidate_screen();
@@ -191,30 +191,30 @@ bool track_design_save(uint8 rideIndex)
     return true;
 }
 
-bool track_design_save_contains_tile_element(rct_tile_element *mapElement)
+bool track_design_save_contains_tile_element(rct_tile_element *tileElement)
 {
-    for (size_t i = 0; i < _trackSavedMapElementsCount; i++) {
-        if (_trackSavedMapElements[i] == mapElement) {
+    for (size_t i = 0; i < _trackSavedTileElementsCount; i++) {
+        if (_trackSavedTileElements[i] == tileElement) {
             return true;
         }
     }
     return false;
 }
 
-static sint32 tile_element_get_total_element_count(rct_tile_element *mapElement)
+static sint32 tile_element_get_total_element_count(rct_tile_element *tileElement)
 {
     sint32 elementCount;
     rct_scenery_entry *sceneryEntry;
     rct_large_scenery_tile *tile;
 
-    switch (tile_element_get_type(mapElement)) {
+    switch (tile_element_get_type(tileElement)) {
     case TILE_ELEMENT_TYPE_PATH:
     case TILE_ELEMENT_TYPE_SCENERY:
     case TILE_ELEMENT_TYPE_WALL:
         return 1;
 
     case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
-        sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
+        sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
         tile = sceneryEntry->large_scenery.tiles;
         elementCount = 0;
         do {
@@ -232,15 +232,15 @@ static sint32 tile_element_get_total_element_count(rct_tile_element *mapElement)
  *
  *  rct2: 0x006D2ED2
  */
-static bool track_design_save_can_add_tile_element(rct_tile_element *mapElement)
+static bool track_design_save_can_add_tile_element(rct_tile_element *tileElement)
 {
-    size_t newElementCount = tile_element_get_total_element_count(mapElement);
+    size_t newElementCount = tile_element_get_total_element_count(tileElement);
     if (newElementCount == 0) {
         return false;
     }
 
     // Get number of spare elements left
-    size_t spareSavedElements = TRACK_MAX_SAVED_TILE_ELEMENTS - _trackSavedMapElementsCount;
+    size_t spareSavedElements = TRACK_MAX_SAVED_TILE_ELEMENTS - _trackSavedTileElementsCount;
     if (newElementCount > spareSavedElements) {
         // No more spare saved elements left
         return false;
@@ -253,15 +253,15 @@ static bool track_design_save_can_add_tile_element(rct_tile_element *mapElement)
  *
  *  rct2: 0x006D2F4C
  */
-static void track_design_save_push_tile_element(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_push_tile_element(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    if (_trackSavedMapElementsCount < TRACK_MAX_SAVED_TILE_ELEMENTS) {
-        _trackSavedMapElements[_trackSavedMapElementsCount++] = mapElement;
+    if (_trackSavedTileElementsCount < TRACK_MAX_SAVED_TILE_ELEMENTS) {
+        _trackSavedTileElements[_trackSavedTileElementsCount++] = tileElement;
         map_invalidate_tile_full(x, y);
 
 #ifndef NO_RCT2
         // Required as drawing still uses 0xFFFFFFFF as a list terminator
-        _trackSavedMapElements[_trackSavedMapElementsCount] = NULL;
+        _trackSavedTileElements[_trackSavedTileElementsCount] = NULL;
 #endif
     }
 }
@@ -272,7 +272,7 @@ static void track_design_save_push_tile_element(sint32 x, sint32 y, rct_tile_ele
  */
 static void track_design_save_push_tile_element_desc(rct_object_entry *entry, sint32 x, sint32 y, sint32 z, uint8 flags, uint8 primaryColour, uint8 secondaryColour)
 {
-    rct_td6_scenery_element *item = &_trackSavedMapElementsDesc[_trackSavedMapElementsDescCount++];
+    rct_td6_scenery_element *item = &_trackSavedTileElementsDesc[_trackSavedTileElementsDescCount++];
     item->scenery_object = *entry;
     item->x = x / 32;
     item->y = y / 32;
@@ -282,35 +282,35 @@ static void track_design_save_push_tile_element_desc(rct_object_entry *entry, si
     item->secondary_colour = secondaryColour;
 }
 
-static void track_design_save_add_scenery(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_add_scenery(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    sint32 entryType = mapElement->properties.scenery.type;
+    sint32 entryType = tileElement->properties.scenery.type;
     rct_object_entry *entry = (rct_object_entry*)&object_entry_groups[OBJECT_TYPE_SMALL_SCENERY].entries[entryType];
 
     uint8 flags = 0;
-    flags |= mapElement->type & 3;
-    flags |= (mapElement->type & 0xC0) >> 4;
+    flags |= tileElement->type & 3;
+    flags |= (tileElement->type & 0xC0) >> 4;
 
-    uint8 primaryColour = scenery_small_get_primary_colour(mapElement);
-    uint8 secondaryColour = scenery_small_get_secondary_colour(mapElement);
+    uint8 primaryColour = scenery_small_get_primary_colour(tileElement);
+    uint8 secondaryColour = scenery_small_get_secondary_colour(tileElement);
 
-    track_design_save_push_tile_element(x, y, mapElement);
-    track_design_save_push_tile_element_desc(entry, x, y, mapElement->base_height, flags, primaryColour, secondaryColour);
+    track_design_save_push_tile_element(x, y, tileElement);
+    track_design_save_push_tile_element_desc(entry, x, y, tileElement->base_height, flags, primaryColour, secondaryColour);
 }
 
-static void track_design_save_add_large_scenery(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_add_large_scenery(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
     rct_large_scenery_tile *sceneryTiles, *tile;
     sint32 x0, y0, z0, z;
     sint32 direction, sequence;
 
-    sint32 entryType = mapElement->properties.scenerymultiple.type & 0x3FF;
+    sint32 entryType = tileElement->properties.scenerymultiple.type & 0x3FF;
     rct_object_entry *entry = (rct_object_entry*)&object_entry_groups[OBJECT_TYPE_LARGE_SCENERY].entries[entryType];
     sceneryTiles = get_large_scenery_entry(entryType)->large_scenery.tiles;
 
-    z = mapElement->base_height;
-    direction = mapElement->type & 3;
-    sequence = mapElement->properties.scenerymultiple.type >> 10;
+    z = tileElement->base_height;
+    direction = tileElement->type & 3;
+    sequence = tileElement->properties.scenerymultiple.type >> 10;
 
     if (!map_large_scenery_get_origin(x, y, z, direction, sequence, &x0, &y0, &z0, NULL)) {
         return;
@@ -326,73 +326,73 @@ static void track_design_save_add_large_scenery(sint32 x, sint32 y, rct_tile_ele
         x = x0 + offsetX;
         y = y0 + offsetY;
         z = (z0 + tile->z_offset) / 8;
-        mapElement = map_get_large_scenery_segment(x, y, z, direction, sequence);
-        if (mapElement != NULL) {
+        tileElement = map_get_large_scenery_segment(x, y, z, direction, sequence);
+        if (tileElement != NULL) {
             if (sequence == 0) {
-                uint8 flags = mapElement->type & 3;
-                uint8 primaryColour = mapElement->properties.scenerymultiple.colour[0] & 0x1F;
-                uint8 secondaryColour = mapElement->properties.scenerymultiple.colour[1] & 0x1F;
+                uint8 flags = tileElement->type & 3;
+                uint8 primaryColour = tileElement->properties.scenerymultiple.colour[0] & 0x1F;
+                uint8 secondaryColour = tileElement->properties.scenerymultiple.colour[1] & 0x1F;
 
                 track_design_save_push_tile_element_desc(entry, x, y, z, flags, primaryColour, secondaryColour);
             }
-            track_design_save_push_tile_element(x, y, mapElement);
+            track_design_save_push_tile_element(x, y, tileElement);
         }
     }
 }
 
-static void track_design_save_add_wall(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_add_wall(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    sint32 entryType = mapElement->properties.wall.type;
+    sint32 entryType = tileElement->properties.wall.type;
     rct_object_entry *entry = (rct_object_entry*)&object_entry_groups[OBJECT_TYPE_WALLS].entries[entryType];
 
     uint8 flags = 0;
-    flags |= mapElement->type & 3;
-    flags |= mapElement->properties.wall.colour_3 << 2;
+    flags |= tileElement->type & 3;
+    flags |= tileElement->properties.wall.colour_3 << 2;
 
-    uint8 secondaryColour = wall_element_get_secondary_colour(mapElement);
-    uint8 primaryColour = mapElement->properties.wall.colour_1 & 0x1F;
+    uint8 secondaryColour = wall_element_get_secondary_colour(tileElement);
+    uint8 primaryColour = tileElement->properties.wall.colour_1 & 0x1F;
 
-    track_design_save_push_tile_element(x, y, mapElement);
-    track_design_save_push_tile_element_desc(entry, x, y, mapElement->base_height, flags, primaryColour, secondaryColour);
+    track_design_save_push_tile_element(x, y, tileElement);
+    track_design_save_push_tile_element_desc(entry, x, y, tileElement->base_height, flags, primaryColour, secondaryColour);
 }
 
-static void track_design_save_add_footpath(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_add_footpath(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    sint32 entryType = mapElement->properties.path.type >> 4;
+    sint32 entryType = tileElement->properties.path.type >> 4;
     rct_object_entry *entry = (rct_object_entry*)&object_entry_groups[OBJECT_TYPE_PATHS].entries[entryType];
 
     uint8 flags = 0;
-    flags |= mapElement->properties.path.edges & 0x0F;
-    flags |= (mapElement->properties.path.type & 4) << 2;
-    flags |= (mapElement->properties.path.type & 3) << 5;
-    flags |= (mapElement->type & 1) << 7;
+    flags |= tileElement->properties.path.edges & 0x0F;
+    flags |= (tileElement->properties.path.type & 4) << 2;
+    flags |= (tileElement->properties.path.type & 3) << 5;
+    flags |= (tileElement->type & 1) << 7;
 
-    track_design_save_push_tile_element(x, y, mapElement);
-    track_design_save_push_tile_element_desc(entry, x, y, mapElement->base_height, flags, 0, 0);
+    track_design_save_push_tile_element(x, y, tileElement);
+    track_design_save_push_tile_element_desc(entry, x, y, tileElement->base_height, flags, 0, 0);
 }
 
 /**
  *
  *  rct2: 0x006D2B3C
  */
-static bool track_design_save_add_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *mapElement)
+static bool track_design_save_add_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    if (!track_design_save_can_add_tile_element(mapElement)) {
+    if (!track_design_save_can_add_tile_element(tileElement)) {
         return false;
     }
 
     switch (interactionType) {
     case VIEWPORT_INTERACTION_ITEM_SCENERY:
-        track_design_save_add_scenery(x, y, mapElement);
+        track_design_save_add_scenery(x, y, tileElement);
         return true;
     case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
-        track_design_save_add_large_scenery(x, y, mapElement);
+        track_design_save_add_large_scenery(x, y, tileElement);
         return true;
     case VIEWPORT_INTERACTION_ITEM_WALL:
-        track_design_save_add_wall(x, y, mapElement);
+        track_design_save_add_wall(x, y, tileElement);
         return true;
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH:
-        track_design_save_add_footpath(x, y, mapElement);
+        track_design_save_add_footpath(x, y, tileElement);
         return true;
     default:
         return false;
@@ -403,33 +403,33 @@ static bool track_design_save_add_tile_element(sint32 interactionType, sint32 x,
  *
  *  rct2: 0x006D2F78
  */
-static void track_design_save_pop_tile_element(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_pop_tile_element(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
     map_invalidate_tile_full(x, y);
 
     // Find index of map element to remove
     size_t removeIndex = SIZE_MAX;
-    for (size_t i = 0; i < _trackSavedMapElementsCount; i++) {
-        if (_trackSavedMapElements[i] == mapElement) {
+    for (size_t i = 0; i < _trackSavedTileElementsCount; i++) {
+        if (_trackSavedTileElements[i] == tileElement) {
             removeIndex = i;
         }
     }
 
     // Remove map element from list
     if (removeIndex != SIZE_MAX) {
-        size_t remainingNumItems = _trackSavedMapElementsCount - removeIndex - 1;
+        size_t remainingNumItems = _trackSavedTileElementsCount - removeIndex - 1;
         if (remainingNumItems > 0) {
             memmove(
-                &_trackSavedMapElements[removeIndex],
-                &_trackSavedMapElements[removeIndex + 1],
+                &_trackSavedTileElements[removeIndex],
+                &_trackSavedTileElements[removeIndex + 1],
                 remainingNumItems * sizeof(rct_tile_element*)
             );
         }
-        _trackSavedMapElementsCount--;
+        _trackSavedTileElementsCount--;
 #ifdef NO_RCT2
-        _trackSavedMapElements[_trackSavedMapElementsCount] = NULL;
+        _trackSavedTileElements[_trackSavedTileElementsCount] = NULL;
 #else
-        _trackSavedMapElements[_trackSavedMapElementsCount] = NULL;
+        _trackSavedTileElements[_trackSavedTileElementsCount] = NULL;
 #endif
     }
 }
@@ -441,8 +441,8 @@ static void track_design_save_pop_tile_element(sint32 x, sint32 y, rct_tile_elem
 static void track_design_save_pop_tile_element_desc(rct_object_entry *entry, sint32 x, sint32 y, sint32 z, uint8 flags, uint8 primaryColour, uint8 secondaryColour)
 {
     size_t removeIndex = SIZE_MAX;
-    for (size_t i = 0; i < _trackSavedMapElementsDescCount; i++) {
-        rct_td6_scenery_element *item = &_trackSavedMapElementsDesc[i];
+    for (size_t i = 0; i < _trackSavedTileElementsDescCount; i++) {
+        rct_td6_scenery_element *item = &_trackSavedTileElementsDesc[i];
         if (item->x != x / 32) continue;
         if (item->y != y / 32) continue;
         if (item->z != z) continue;
@@ -453,47 +453,47 @@ static void track_design_save_pop_tile_element_desc(rct_object_entry *entry, sin
     }
 
     if (removeIndex != SIZE_MAX) {
-        size_t remainingNumItems = _trackSavedMapElementsDescCount - removeIndex - 1;
+        size_t remainingNumItems = _trackSavedTileElementsDescCount - removeIndex - 1;
         if (remainingNumItems > 0) {
             memmove(
-                &_trackSavedMapElementsDesc[removeIndex],
-                &_trackSavedMapElementsDesc[removeIndex + 1],
+                &_trackSavedTileElementsDesc[removeIndex],
+                &_trackSavedTileElementsDesc[removeIndex + 1],
                 remainingNumItems * sizeof(rct_td6_scenery_element)
             );
         }
-        _trackSavedMapElementsDescCount--;
+        _trackSavedTileElementsDescCount--;
     }
 }
 
-static void track_design_save_remove_scenery(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_remove_scenery(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    sint32 entryType = mapElement->properties.scenery.type;
+    sint32 entryType = tileElement->properties.scenery.type;
     rct_object_entry *entry = (rct_object_entry*)&object_entry_groups[OBJECT_TYPE_SMALL_SCENERY].entries[entryType];
 
     uint8 flags = 0;
-    flags |= mapElement->type & 3;
-    flags |= (mapElement->type & 0xC0) >> 4;
+    flags |= tileElement->type & 3;
+    flags |= (tileElement->type & 0xC0) >> 4;
 
-    uint8 primaryColour = scenery_small_get_primary_colour(mapElement);
-    uint8 secondaryColour = scenery_small_get_secondary_colour(mapElement);
+    uint8 primaryColour = scenery_small_get_primary_colour(tileElement);
+    uint8 secondaryColour = scenery_small_get_secondary_colour(tileElement);
 
-    track_design_save_pop_tile_element(x, y, mapElement);
-    track_design_save_pop_tile_element_desc(entry, x, y, mapElement->base_height, flags, primaryColour, secondaryColour);
+    track_design_save_pop_tile_element(x, y, tileElement);
+    track_design_save_pop_tile_element_desc(entry, x, y, tileElement->base_height, flags, primaryColour, secondaryColour);
 }
 
-static void track_design_save_remove_large_scenery(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_remove_large_scenery(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
     rct_large_scenery_tile *sceneryTiles, *tile;
     sint32 x0, y0, z0, z;
     sint32 direction, sequence;
 
-    sint32 entryType = mapElement->properties.scenerymultiple.type & 0x3FF;
+    sint32 entryType = tileElement->properties.scenerymultiple.type & 0x3FF;
     rct_object_entry *entry = (rct_object_entry*)&object_entry_groups[OBJECT_TYPE_LARGE_SCENERY].entries[entryType];
     sceneryTiles = get_large_scenery_entry(entryType)->large_scenery.tiles;
 
-    z = mapElement->base_height;
-    direction = mapElement->type & 3;
-    sequence = mapElement->properties.scenerymultiple.type >> 10;
+    z = tileElement->base_height;
+    direction = tileElement->type & 3;
+    sequence = tileElement->properties.scenerymultiple.type >> 10;
 
     if (!map_large_scenery_get_origin(x, y, z, direction, sequence, &x0, &y0, &z0, NULL)) {
         return;
@@ -509,90 +509,90 @@ static void track_design_save_remove_large_scenery(sint32 x, sint32 y, rct_tile_
         x = x0 + offsetX;
         y = y0 + offsetY;
         z = (z0 + tile->z_offset) / 8;
-        mapElement = map_get_large_scenery_segment(x, y, z, direction, sequence);
-        if (mapElement != NULL) {
+        tileElement = map_get_large_scenery_segment(x, y, z, direction, sequence);
+        if (tileElement != NULL) {
             if (sequence == 0) {
-                uint8 flags = mapElement->type & 3;
-                uint8 primaryColour = mapElement->properties.scenerymultiple.colour[0] & 0x1F;
-                uint8 secondaryColour = mapElement->properties.scenerymultiple.colour[1] & 0x1F;
+                uint8 flags = tileElement->type & 3;
+                uint8 primaryColour = tileElement->properties.scenerymultiple.colour[0] & 0x1F;
+                uint8 secondaryColour = tileElement->properties.scenerymultiple.colour[1] & 0x1F;
 
                 track_design_save_pop_tile_element_desc(entry, x, y, z, flags, primaryColour, secondaryColour);
             }
-            track_design_save_pop_tile_element(x, y, mapElement);
+            track_design_save_pop_tile_element(x, y, tileElement);
         }
     }
 }
 
-static void track_design_save_remove_wall(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_remove_wall(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    sint32 entryType = mapElement->properties.wall.type;
+    sint32 entryType = tileElement->properties.wall.type;
     rct_object_entry *entry = (rct_object_entry*)&object_entry_groups[OBJECT_TYPE_WALLS].entries[entryType];
 
     uint8 flags = 0;
-    flags |= mapElement->type & 3;
-    flags |= mapElement->properties.wall.colour_3 << 2;
+    flags |= tileElement->type & 3;
+    flags |= tileElement->properties.wall.colour_3 << 2;
 
-    uint8 secondaryColour = wall_element_get_secondary_colour(mapElement);
-    uint8 primaryColour = mapElement->properties.wall.colour_1 & 0x1F;
+    uint8 secondaryColour = wall_element_get_secondary_colour(tileElement);
+    uint8 primaryColour = tileElement->properties.wall.colour_1 & 0x1F;
 
-    track_design_save_pop_tile_element(x, y, mapElement);
-    track_design_save_pop_tile_element_desc(entry, x, y, mapElement->base_height, flags, primaryColour, secondaryColour);
+    track_design_save_pop_tile_element(x, y, tileElement);
+    track_design_save_pop_tile_element_desc(entry, x, y, tileElement->base_height, flags, primaryColour, secondaryColour);
 }
 
-static void track_design_save_remove_footpath(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_remove_footpath(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    sint32 entryType = mapElement->properties.path.type >> 4;
+    sint32 entryType = tileElement->properties.path.type >> 4;
     rct_object_entry *entry = (rct_object_entry*)&object_entry_groups[OBJECT_TYPE_PATHS].entries[entryType];
 
     uint8 flags = 0;
-    flags |= mapElement->properties.path.edges & 0x0F;
-    flags |= (mapElement->properties.path.type & 4) << 2;
-    flags |= (mapElement->properties.path.type & 3) << 5;
-    flags |= (mapElement->type & 1) << 7;
+    flags |= tileElement->properties.path.edges & 0x0F;
+    flags |= (tileElement->properties.path.type & 4) << 2;
+    flags |= (tileElement->properties.path.type & 3) << 5;
+    flags |= (tileElement->type & 1) << 7;
 
-    track_design_save_pop_tile_element(x, y, mapElement);
-    track_design_save_pop_tile_element_desc(entry, x, y, mapElement->base_height, flags, 0, 0);
+    track_design_save_pop_tile_element(x, y, tileElement);
+    track_design_save_pop_tile_element_desc(entry, x, y, tileElement->base_height, flags, 0, 0);
 }
 
 /**
  *
  *  rct2: 0x006D2B3C
  */
-static void track_design_save_remove_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *mapElement)
+static void track_design_save_remove_tile_element(sint32 interactionType, sint32 x, sint32 y, rct_tile_element *tileElement)
 {
     switch (interactionType) {
     case VIEWPORT_INTERACTION_ITEM_SCENERY:
-        track_design_save_remove_scenery(x, y, mapElement);
+        track_design_save_remove_scenery(x, y, tileElement);
         break;
     case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
-        track_design_save_remove_large_scenery(x, y, mapElement);
+        track_design_save_remove_large_scenery(x, y, tileElement);
         break;
     case VIEWPORT_INTERACTION_ITEM_WALL:
-        track_design_save_remove_wall(x, y, mapElement);
+        track_design_save_remove_wall(x, y, tileElement);
         break;
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH:
-        track_design_save_remove_footpath(x, y, mapElement);
+        track_design_save_remove_footpath(x, y, tileElement);
         break;
     }
 }
 
-static bool track_design_save_should_select_scenery_around(sint32 rideIndex, rct_tile_element *mapElement)
+static bool track_design_save_should_select_scenery_around(sint32 rideIndex, rct_tile_element *tileElement)
 {
-    switch (tile_element_get_type(mapElement)) {
+    switch (tile_element_get_type(tileElement)) {
     case TILE_ELEMENT_TYPE_PATH:
-        if ((mapElement->type & 1) && mapElement->properties.path.addition_status == rideIndex)
+        if ((tileElement->type & 1) && tileElement->properties.path.addition_status == rideIndex)
             return true;
         break;
     case TILE_ELEMENT_TYPE_TRACK:
-        if (mapElement->properties.track.ride_index == rideIndex)
+        if (tileElement->properties.track.ride_index == rideIndex)
             return true;
         break;
     case TILE_ELEMENT_TYPE_ENTRANCE:
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
             break;
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT)
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT)
             break;
-        if (mapElement->properties.entrance.ride_index == rideIndex)
+        if (tileElement->properties.entrance.ride_index == rideIndex)
             return true;
         break;
     }
@@ -601,18 +601,18 @@ static bool track_design_save_should_select_scenery_around(sint32 rideIndex, rct
 
 static void track_design_save_select_nearby_scenery_for_tile(sint32 rideIndex, sint32 cx, sint32 cy)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     for (sint32 y = cy - TRACK_NEARBY_SCENERY_DISTANCE; y <= cy + TRACK_NEARBY_SCENERY_DISTANCE; y++) {
         for (sint32 x = cx - TRACK_NEARBY_SCENERY_DISTANCE; x <= cx + TRACK_NEARBY_SCENERY_DISTANCE; x++) {
-            mapElement = map_get_first_element_at(x, y);
+            tileElement = map_get_first_element_at(x, y);
             do {
                 sint32 interactionType = VIEWPORT_INTERACTION_ITEM_NONE;
-                switch (tile_element_get_type(mapElement)) {
+                switch (tile_element_get_type(tileElement)) {
                 case TILE_ELEMENT_TYPE_PATH:
-                    if (!(mapElement->type & 1))
+                    if (!(tileElement->type & 1))
                         interactionType = VIEWPORT_INTERACTION_ITEM_FOOTPATH;
-                    else if (mapElement->properties.path.addition_status == rideIndex)
+                    else if (tileElement->properties.path.addition_status == rideIndex)
                         interactionType = VIEWPORT_INTERACTION_ITEM_FOOTPATH;
                     break;
                 case TILE_ELEMENT_TYPE_SCENERY:
@@ -627,11 +627,11 @@ static void track_design_save_select_nearby_scenery_for_tile(sint32 rideIndex, s
                 }
 
                 if (interactionType != VIEWPORT_INTERACTION_ITEM_NONE) {
-                    if (!track_design_save_contains_tile_element(mapElement)) {
-                        track_design_save_add_tile_element(interactionType, x * 32, y * 32, mapElement);
+                    if (!track_design_save_contains_tile_element(tileElement)) {
+                        track_design_save_add_tile_element(interactionType, x * 32, y * 32, tileElement);
                     }
                 }
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
         }
     }
 }
@@ -640,13 +640,13 @@ static void track_design_save_select_nearby_scenery_for_tile(sint32 rideIndex, s
 static bool track_design_save_copy_scenery_to_td6(rct_track_td6 *td6)
 {
     // Copy TD6 scenery elements to new memory and add end marker
-    size_t totalSceneryElementsSize = _trackSavedMapElementsDescCount * sizeof(rct_td6_scenery_element);
+    size_t totalSceneryElementsSize = _trackSavedTileElementsDescCount * sizeof(rct_td6_scenery_element);
     td6->scenery_elements = malloc(totalSceneryElementsSize + 1);
-    memcpy(td6->scenery_elements, _trackSavedMapElementsDesc, totalSceneryElementsSize);
-    *((uint8*)&td6->scenery_elements[_trackSavedMapElementsDescCount]) = 0xFF;
+    memcpy(td6->scenery_elements, _trackSavedTileElementsDesc, totalSceneryElementsSize);
+    *((uint8*)&td6->scenery_elements[_trackSavedTileElementsDescCount]) = 0xFF;
 
     // Run an element loop
-    for (size_t i = 0; i < _trackSavedMapElementsDescCount; i++) {
+    for (size_t i = 0; i < _trackSavedTileElementsDescCount; i++) {
         rct_td6_scenery_element *scenery = &td6->scenery_elements[i];
 
         switch (scenery->scenery_object.flags & 0x0F) {
@@ -805,21 +805,21 @@ static rct_track_td6 *track_design_save_to_td6(uint8 rideIndex)
  */
 static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td6)
 {
-    rct_tile_element *mapElement = NULL;
+    rct_tile_element *tileElement = NULL;
     bool mapFound = false;
     sint16 startX = 0;
     sint16 startY = 0;
     for (startY = 0; startY < 8192; startY += 32) {
         for (startX = 0; startX < 8192; startX += 32) {
-            mapElement = map_get_first_element_at(startX >> 5, startY >> 5);
+            tileElement = map_get_first_element_at(startX >> 5, startY >> 5);
             do {
-                if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                     continue;
-                if (mapElement->properties.track.ride_index == rideIndex){
+                if (tileElement->properties.track.ride_index == rideIndex){
                     mapFound = true;
                     break;
                 }
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
             if (mapFound) {
                 break;
             }
@@ -834,7 +834,7 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
         return false;
     }
 
-    gTrackPreviewOrigin = (LocationXYZ16) { startX, startY, mapElement->base_height * 8 };
+    gTrackPreviewOrigin = (LocationXYZ16) { startX, startY, tileElement->base_height * 8 };
 
     size_t numMazeElements = 0;
     td6->maze_elements = calloc(8192, sizeof(rct_td6_maze_element));
@@ -845,12 +845,12 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
     // must restart on 0
     for (sint16 y = startY, x = startX; y < 8192; y += 32) {
         for (; x < 8192; x += 32) {
-            mapElement = map_get_first_element_at(x / 32, y / 32);
+            tileElement = map_get_first_element_at(x / 32, y / 32);
             do {
-                if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-                if (mapElement->properties.track.ride_index != rideIndex) continue;
+                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+                if (tileElement->properties.track.ride_index != rideIndex) continue;
 
-                maze->maze_entry = mapElement->properties.track.maze_entry;
+                maze->maze_entry = tileElement->properties.track.maze_entry;
                 maze->x = (x - startX) / 32;
                 maze->y = (y - startY) / 32;
                 maze++;
@@ -861,7 +861,7 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
                     SafeFree(td6->maze_elements);
                     return false;
                 }
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
 
         }
         x = 0;
@@ -879,15 +879,15 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
     sint16 x = location.x * 32;
     sint16 y = location.y * 32;
 
-    mapElement = map_get_first_element_at(location.x, location.y);
+    tileElement = map_get_first_element_at(location.x, location.y);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE) continue;
-        if (mapElement->properties.entrance.ride_index == rideIndex) break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE) continue;
+        if (tileElement->properties.entrance.ride_index == rideIndex) break;
+    } while (!tile_element_is_last_for_tile(tileElement++));
     // Add something that stops this from walking off the end
 
-    uint8 entrance_direction = tile_element_get_direction(mapElement);
+    uint8 entrance_direction = tile_element_get_direction(tileElement);
     maze->direction = entrance_direction;
     maze->type = 8;
     maze->x = (sint8)((x - startX) / 32);
@@ -904,15 +904,15 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
 
     x = location.x * 32;
     y = location.y * 32;
-    mapElement = map_get_first_element_at(location.x, location.y);
+    tileElement = map_get_first_element_at(location.x, location.y);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT) continue;
-        if (mapElement->properties.entrance.ride_index == rideIndex) break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT) continue;
+        if (tileElement->properties.entrance.ride_index == rideIndex) break;
+    } while (!tile_element_is_last_for_tile(tileElement++));
     // Add something that stops this from walking off the end
 
-    uint8 exit_direction = tile_element_get_direction(mapElement);
+    uint8 exit_direction = tile_element_get_direction(tileElement);
     maze->direction = exit_direction;
     maze->type = 0x80;
     maze->x = (sint8)((x - startX) / 32);
diff --git a/src/openrct2/ride/track_paint.c b/src/openrct2/ride/track_paint.c
index a483d3804b..650870b77e 100644
--- a/src/openrct2/ride/track_paint.c
+++ b/src/openrct2/ride/track_paint.c
@@ -203,7 +203,7 @@ enum
 
 bool gUseOriginalRidePaint = false;
 
-bool track_paint_util_has_fence(enum edge_t edge, LocationXY16 position, rct_tile_element * mapElement, Ride * ride, uint8 rotation)
+bool track_paint_util_has_fence(enum edge_t edge, LocationXY16 position, rct_tile_element * tileElement, Ride * ride, uint8 rotation)
 {
     LocationXY16 offset = { 0, 0 };
     switch (edge) {
@@ -225,7 +225,7 @@ bool track_paint_util_has_fence(enum edge_t edge, LocationXY16 position, rct_til
         ((position.x / 32) + offset.x) |
         (((position.y / 32) + offset.y) * (1 << 8));
 
-    sint32 entranceId = tile_element_get_station(mapElement);
+    sint32 entranceId = tile_element_get_station(tileElement);
 
     return (ride->entrances[entranceId].xy != entranceLoc && ride->exits[entranceId].xy != entranceLoc);
 }
@@ -247,23 +247,23 @@ void track_paint_util_paint_floor(paint_session * session, uint8 edges, uint32 c
     sub_98197C(session, imageId | colourFlags, 0, 0, 32, 32, 1, height, 0, 0, height, rotation);
 }
 
-void track_paint_util_paint_fences(paint_session * session, uint8 edges, LocationXY16 position, rct_tile_element * mapElement, Ride * ride, uint32 colourFlags, uint16 height, const uint32 fenceSprites[4], uint8 rotation)
+void track_paint_util_paint_fences(paint_session * session, uint8 edges, LocationXY16 position, rct_tile_element * tileElement, Ride * ride, uint32 colourFlags, uint16 height, const uint32 fenceSprites[4], uint8 rotation)
 {
     uint32 imageId;
 
-    if (edges & EDGE_NW && track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, rotation)) {
+    if (edges & EDGE_NW && track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, rotation)) {
         imageId = fenceSprites[3] | colourFlags;
         sub_98199C(session, imageId, 0, 0, 32, 1, 7, height, 0, 2, height + 2, rotation);
     }
-    if (edges & EDGE_NE && track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, rotation)) {
+    if (edges & EDGE_NE && track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, rotation)) {
         imageId = fenceSprites[0] | colourFlags;
         sub_98199C(session, imageId, 0, 0, 1, 32, 7, height, 2, 0, height + 2, rotation);
     }
-    if (edges & EDGE_SE && track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, rotation)) {
+    if (edges & EDGE_SE && track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, rotation)) {
         imageId = fenceSprites[1] | colourFlags;
         sub_98197C(session, imageId, 0, 0, 32, 1, 7, height, 0, 30, height + 2, rotation);
     }
-    if (edges & EDGE_SW && track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, rotation)) {
+    if (edges & EDGE_SW && track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, rotation)) {
         imageId = fenceSprites[2] | colourFlags;
         sub_98197C(session, imageId, 0, 0, 1, 32, 7, height, 30, 0, height + 2, rotation);
     }
@@ -281,44 +281,44 @@ bool track_paint_util_should_paint_supports(LocationXY16 position)
     return false;
 }
 
-void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_tile_element * mapElement, sint32 fenceOffsetA, sint32 fenceOffsetB);
+void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_tile_element * tileElement, sint32 fenceOffsetA, sint32 fenceOffsetB);
 
-void track_paint_util_draw_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element * mapElement)
+void track_paint_util_draw_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element * tileElement)
 {
-    track_paint_util_draw_station_impl(session, rideIndex, trackSequence, direction, height, height, mapElement, 5, 7);
+    track_paint_util_draw_station_impl(session, rideIndex, trackSequence, direction, height, height, tileElement, 5, 7);
 }
 
-void track_paint_util_draw_station_2(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element * mapElement, sint32 fenceOffsetA, sint32 fenceOffsetB)
+void track_paint_util_draw_station_2(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element * tileElement, sint32 fenceOffsetA, sint32 fenceOffsetB)
 {
-    track_paint_util_draw_station_impl(session, rideIndex, trackSequence, direction, height, height, mapElement, fenceOffsetA, fenceOffsetB);
+    track_paint_util_draw_station_impl(session, rideIndex, trackSequence, direction, height, height, tileElement, fenceOffsetA, fenceOffsetB);
 }
 
-void track_paint_util_draw_station_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_tile_element * mapElement)
+void track_paint_util_draw_station_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_tile_element * tileElement)
 {
-    track_paint_util_draw_station_impl(session, rideIndex, trackSequence, direction, height, coverHeight, mapElement, 5, 7);
+    track_paint_util_draw_station_impl(session, rideIndex, trackSequence, direction, height, coverHeight, tileElement, 5, 7);
 }
 
-void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_tile_element * mapElement, sint32 fenceOffsetA, sint32 fenceOffsetB)
+void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_tile_element * tileElement, sint32 fenceOffsetA, sint32 fenceOffsetB)
 {
     LocationXY16 position = session->MapPosition;
     Ride * ride = get_ride(rideIndex);
     const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
-    const bool hasGreenLight = tile_element_get_green_light(mapElement);
+    const bool hasGreenLight = tile_element_get_green_light(tileElement);
 
     bool hasFence;
     uint32 imageId;
 
     if (direction == 0 || direction == 2) {
         //height += 5 (height + 5);
-        hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 0) {
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 0) {
             if (hasGreenLight) {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_END_GREEN_LIGHT_SW_NE : SPR_STATION_PLATFORM_END_GREEN_LIGHT_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
             } else {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_END_RED_LIGHT_SW_NE : SPR_STATION_PLATFORM_END_RED_LIGHT_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
             }
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 2) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 2) {
             imageId = (hasFence ? SPR_STATION_PLATFORM_BEGIN_FENCED_SW_NE : SPR_STATION_PLATFORM_BEGIN_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
         } else {
             imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_SW_NE : SPR_STATION_PLATFORM_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
@@ -328,9 +328,9 @@ void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex
         track_paint_util_draw_station_covers(session, EDGE_NW, hasFence, entranceStyle, direction, coverHeight);
         //height += 5 (height + 5)
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 0) {
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 0) {
             imageId = (hasGreenLight ? SPR_STATION_PLATFORM_END_GREEN_LIGHT_SW_NE : SPR_STATION_PLATFORM_END_RED_LIGHT_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 2) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 2) {
             imageId = SPR_STATION_PLATFORM_BEGIN_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
         } else {
             imageId = SPR_STATION_PLATFORM_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
@@ -338,21 +338,21 @@ void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex
         sub_98196C(session, imageId, 0, 24, 32, 8, 1, height + fenceOffsetA, get_current_rotation());
         //height += 2 (height + 7)
 
-        hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
         if (hasFence) {
-            if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
+            if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
                 imageId = SPR_STATION_BEGIN_ANGLE_FENCE_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
-            } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
+            } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
                 imageId = SPR_STATION_LIGHT_BACK_ANGLE_FENCED_NE_SW | session->TrackColours[SCHEME_SUPPORTS];
             } else {
                 imageId = SPR_STATION_FENCE_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
             }
             sub_98196C(session, imageId, 0, 31, 32, 1, 7, height + fenceOffsetB, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
             // Addition: draw only small fence if there is an entrance/exit at the beginning
             imageId = SPR_STATION_FENCE_SMALL_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 23, 1, 8, 7, height + fenceOffsetB, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
             // Addition: draw only small fence if there is an entrance/exit at the end
             imageId = SPR_STATION_LIGHT_BACK_NE_SW | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 23, 1, 8, 7, height + fenceOffsetB, get_current_rotation());
@@ -361,24 +361,24 @@ void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex
         track_paint_util_draw_station_covers(session, EDGE_SE, hasFence, entranceStyle, direction, coverHeight);
         //height += 7 (height + 7)
 
-        if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
+        if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
             imageId = SPR_STATION_FENCE_SMALL_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 0, 1, 8, 7, height + fenceOffsetB, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
             imageId = SPR_STATION_LIGHT_BACK_NE_SW | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 0, 1, 8, 7, height + fenceOffsetB, get_current_rotation());
         }
     } else if (direction == 1 || direction == 3) {
         //height += 5 (height + 5);
-        hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 3) {
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 3) {
             if (hasGreenLight) {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_END_GREEN_LIGHT_NW_SE : SPR_STATION_PLATFORM_END_GREEN_LIGHT_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
             } else {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_END_RED_LIGHT_NW_SE : SPR_STATION_PLATFORM_END_RED_LIGHT_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
             }
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 1) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 1) {
             imageId = (hasFence ? SPR_STATION_PLATFORM_BEGIN_FENCED_NW_SE : SPR_STATION_PLATFORM_BEGIN_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
         } else {
             imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_NW_SE : SPR_STATION_PLATFORM_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
@@ -388,9 +388,9 @@ void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex
         track_paint_util_draw_station_covers(session, EDGE_NE, hasFence, entranceStyle, direction, coverHeight);
         //height += 5 (height + 5)
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 3) {
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 3) {
             imageId = (hasGreenLight ? SPR_STATION_PLATFORM_END_GREEN_LIGHT_NW_SE : SPR_STATION_PLATFORM_END_RED_LIGHT_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 1) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 1) {
             imageId = SPR_STATION_PLATFORM_BEGIN_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
         } else {
             imageId = SPR_STATION_PLATFORM_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
@@ -398,21 +398,21 @@ void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex
         sub_98196C(session, imageId, 24, 0, 8, 32, 1, height + fenceOffsetA, get_current_rotation());
         //height += 2 (height + 7)
 
-        hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
         if (hasFence) {
-            if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
+            if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
                 imageId = SPR_STATION_BEGIN_ANGLE_FENCE_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
-            } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
+            } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
                 imageId = SPR_STATION_LIGHT_BACK_ANGLE_FENCED_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             } else {
                 imageId = SPR_STATION_FENCE_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             }
             sub_98196C(session, imageId, 31, 0, 1, 32, 7, height + fenceOffsetB, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
             // Addition: draw only small fence if there is an entrance/exit at the beginning
             imageId = SPR_STATION_FENCE_SMALL_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 23, 31, 8, 1, 7, height + fenceOffsetB, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
             // Addition: draw only small fence if there is an entrance/exit at the end
             imageId = SPR_STATION_LIGHT_BACK_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 23, 31, 8, 1, 7, height + fenceOffsetB, get_current_rotation());
@@ -422,37 +422,37 @@ void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex
         track_paint_util_draw_station_covers(session, EDGE_SW, hasFence, entranceStyle, direction, coverHeight);
         //height += 7 (height + 7)
 
-        if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
+        if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
             imageId = SPR_STATION_FENCE_SMALL_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 0, 31, 8, 1, 7, height + fenceOffsetB, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
             imageId = SPR_STATION_LIGHT_BACK_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 0, 31, 8, 1, 7, height + fenceOffsetB, get_current_rotation());
         }
     }
 }
 
-void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, uint8 stationVariant)
+void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, uint8 stationVariant)
 {
     LocationXY16 position = session->MapPosition;
     Ride * ride = get_ride(rideIndex);
     const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
-    const bool hasGreenLight = tile_element_get_green_light(mapElement);
+    const bool hasGreenLight = tile_element_get_green_light(tileElement);
 
     bool hasFence;
     uint32 imageId;
 
     if (direction == 0 || direction == 2) {
         //height += 5 (height + 5);
-        hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 0) {
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 0) {
             if (hasGreenLight) {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_END_GREEN_LIGHT_SW_NE : SPR_STATION_PLATFORM_END_GREEN_LIGHT_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
             } else {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_END_RED_LIGHT_SW_NE : SPR_STATION_PLATFORM_END_RED_LIGHT_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
             }
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 2) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 2) {
             imageId = (hasFence ? SPR_STATION_PLATFORM_BEGIN_FENCED_SW_NE : SPR_STATION_PLATFORM_BEGIN_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
         } else {
             imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_SW_NE : SPR_STATION_PLATFORM_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
@@ -462,9 +462,9 @@ void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideI
         track_paint_util_draw_station_covers_2(session, EDGE_NW, hasFence, entranceStyle, direction, height, stationVariant);
         //height += 5 (height + 5)
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 0) {
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 0) {
             imageId = (hasGreenLight ? SPR_STATION_PLATFORM_END_GREEN_LIGHT_SW_NE : SPR_STATION_PLATFORM_END_RED_LIGHT_SW_NE) | session->TrackColours[SCHEME_SUPPORTS];
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 2) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 2) {
             imageId = SPR_STATION_PLATFORM_BEGIN_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
         } else {
             imageId = SPR_STATION_PLATFORM_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
@@ -472,21 +472,21 @@ void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideI
         sub_98196C(session, imageId, 0, 24, 32, 8, 1, height + 6, get_current_rotation());
         //height += 2 (height + 7)
 
-        hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
         if (hasFence) {
-            if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
+            if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
                 imageId = SPR_STATION_INVERTED_BEGIN_ANGLE_FENCE_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
-            } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
+            } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
                 imageId = SPR_STATION_INVERTED_LIGHT_BACK_ANGLE_FENCED_NE_SW | session->TrackColours[SCHEME_SUPPORTS];
             } else {
                 imageId = SPR_STATION_INVERTED_FENCE_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
             }
             sub_98196C(session, imageId, 0, 31, 32, 1, 7, height + 8, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
             // Addition: draw only small fence if there is an entrance/exit at the beginning
             imageId = SPR_STATION_FENCE_SMALL_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 23, 1, 8, 7, height + 8, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
             // Addition: draw only small fence if there is an entrance/exit at the end
             imageId = SPR_STATION_LIGHT_BACK_NE_SW | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 23, 1, 8, 7, height + 8, get_current_rotation());
@@ -495,24 +495,24 @@ void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideI
         track_paint_util_draw_station_covers_2(session, EDGE_SE, hasFence, entranceStyle, direction, height, stationVariant);
         //height += 7 (height + 7)
 
-        if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
+        if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 0) {
             imageId = SPR_STATION_FENCE_SMALL_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 0, 1, 8, 7, height + 8, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 2) {
             imageId = SPR_STATION_LIGHT_BACK_NE_SW | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 0, 1, 8, 7, height + 8, get_current_rotation());
         }
     } else if (direction == 1 || direction == 3) {
         //height += 5 (height + 5);
-        hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 3) {
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 3) {
             if (hasGreenLight) {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_END_GREEN_LIGHT_NW_SE : SPR_STATION_PLATFORM_END_GREEN_LIGHT_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
             } else {
                 imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_END_RED_LIGHT_NW_SE : SPR_STATION_PLATFORM_END_RED_LIGHT_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
             }
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 1) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 1) {
             imageId = (hasFence ? SPR_STATION_PLATFORM_BEGIN_FENCED_NW_SE : SPR_STATION_PLATFORM_BEGIN_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
         } else {
             imageId = (hasFence ? SPR_STATION_PLATFORM_FENCED_NW_SE : SPR_STATION_PLATFORM_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
@@ -522,9 +522,9 @@ void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideI
         track_paint_util_draw_station_covers_2(session, EDGE_NE, hasFence, entranceStyle, direction, height, stationVariant);
         //height += 5 (height + 5)
 
-        if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 3) {
+        if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 3) {
             imageId = (hasGreenLight ? SPR_STATION_PLATFORM_END_GREEN_LIGHT_NW_SE : SPR_STATION_PLATFORM_END_RED_LIGHT_NW_SE) | session->TrackColours[SCHEME_SUPPORTS];
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 1) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 1) {
             imageId = SPR_STATION_PLATFORM_BEGIN_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
         } else {
             imageId = SPR_STATION_PLATFORM_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
@@ -532,21 +532,21 @@ void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideI
         sub_98196C(session, imageId, 24, 0, 8, 32, 1, height + 6, get_current_rotation());
         //height += 2 (height + 7)
 
-        hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
         if (hasFence) {
-            if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
+            if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
                 imageId = SPR_STATION_INVERTED_BEGIN_ANGLE_FENCE_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
-            } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
+            } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
                 imageId = SPR_STATION_INVERTED_LIGHT_BACK_ANGLE_FENCED_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             } else {
                 imageId = SPR_STATION_INVERTED_FENCE_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             }
             sub_98196C(session, imageId, 31, 0, 1, 32, 7, height + 8, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
             // Addition: draw only small fence if there is an entrance/exit at the beginning
             imageId = SPR_STATION_FENCE_SMALL_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 23, 31, 8, 1, 7, height + 8, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
             // Addition: draw only small fence if there is an entrance/exit at the end
             imageId = SPR_STATION_LIGHT_BACK_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 23, 31, 8, 1, 7, height + 8, get_current_rotation());
@@ -556,10 +556,10 @@ void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideI
         track_paint_util_draw_station_covers_2(session, EDGE_SW, hasFence, entranceStyle, direction, height, stationVariant);
         //height += 7 (height + 7)
 
-        if (mapElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
+        if (tileElement->properties.track.type == TRACK_ELEM_BEGIN_STATION && direction == 3) {
             imageId = SPR_STATION_FENCE_SMALL_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 0, 31, 8, 1, 7, height + 8, get_current_rotation());
-        } else if (mapElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
+        } else if (tileElement->properties.track.type == TRACK_ELEM_END_STATION && direction == 1) {
             imageId = SPR_STATION_LIGHT_BACK_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 0, 31, 8, 1, 7, height + 8, get_current_rotation());
         }
@@ -641,12 +641,12 @@ bool track_paint_util_draw_station_covers_2(paint_session * session, enum edge_t
     return true;
 }
 
-void track_paint_util_draw_station_platform(paint_session * session, Ride *ride, uint8 direction, sint32 height, sint32 zOffset, rct_tile_element * mapElement)
+void track_paint_util_draw_station_platform(paint_session * session, Ride *ride, uint8 direction, sint32 height, sint32 zOffset, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
     const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
     if (direction & 1) {
-        bool hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
+        bool hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
         uint32 imageId = (hasFence ? SPR_STATION_NARROW_EDGE_FENCED_NE : SPR_STATION_NARROW_EDGE_NE) | session->TrackColours[SCHEME_SUPPORTS];
         sub_98196C(session, imageId, 0, 0, 8, 32, 1, height + zOffset, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_NE, hasFence, entranceStyle, direction, height);
@@ -654,14 +654,14 @@ void track_paint_util_draw_station_platform(paint_session * session, Ride *ride,
         imageId = SPR_STATION_NARROW_EDGE_SW | session->TrackColours[SCHEME_SUPPORTS];
         sub_98196C(session, imageId, 24, 0, 8, 32, 1, height + zOffset, get_current_rotation());
 
-        hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
         if (hasFence) {
             imageId = SPR_STATION_FENCE_NW_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 0, 1, 32, 7, height + zOffset + 2, get_current_rotation());
         }
         track_paint_util_draw_station_covers(session, EDGE_SW, hasFence, entranceStyle, direction, height);
     } else {
-        bool hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, get_current_rotation());
+        bool hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, get_current_rotation());
         uint32 imageId = (hasFence ? SPR_STATION_NARROW_EDGE_FENCED_NW : SPR_STATION_NARROW_EDGE_NW) | session->TrackColours[SCHEME_SUPPORTS];
         sub_98196C(session, imageId, 0, 0, 32, 8, 1, height + zOffset, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_NW, hasFence, entranceStyle, direction, height);
@@ -669,7 +669,7 @@ void track_paint_util_draw_station_platform(paint_session * session, Ride *ride,
         imageId = SPR_STATION_NARROW_EDGE_SE | session->TrackColours[SCHEME_SUPPORTS];
         sub_98196C(session, imageId, 0, 24, 32, 8, 1, height + zOffset, get_current_rotation());
 
-        hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, get_current_rotation());
         if (hasFence) {
             imageId = SPR_STATION_FENCE_SW_NE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 0, 31, 32, 1, 7, height + zOffset + 2, get_current_rotation());
@@ -678,13 +678,13 @@ void track_paint_util_draw_station_platform(paint_session * session, Ride *ride,
     }
 }
 
-void track_paint_util_draw_pier(paint_session * session, Ride * ride, const rct_ride_entrance_definition * entranceStyle, LocationXY16 position, uint8 direction, sint32 height, rct_tile_element * mapElement, uint8 rotation)
+void track_paint_util_draw_pier(paint_session * session, Ride * ride, const rct_ride_entrance_definition * entranceStyle, LocationXY16 position, uint8 direction, sint32 height, rct_tile_element * tileElement, uint8 rotation)
 {
     bool hasFence;
     uint32 imageId;
 
     if (direction & 1) {
-        hasFence = track_paint_util_has_fence(EDGE_NE, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_NE, position, tileElement, ride, get_current_rotation());
         imageId = (hasFence ? SPR_STATION_PIER_EDGE_NE_FENCED : SPR_STATION_PIER_EDGE_NE) | session->TrackColours[SCHEME_SUPPORTS];
         sub_98197C(session, imageId, 0, 0, 6, 32, 1, height, 2, 0, height, get_current_rotation());
         track_paint_util_draw_station_covers(session, EDGE_NE, hasFence, entranceStyle, direction, height);
@@ -692,14 +692,14 @@ void track_paint_util_draw_pier(paint_session * session, Ride * ride, const rct_
         imageId = SPR_STATION_PIER_EDGE_SW | session->TrackColours[SCHEME_SUPPORTS];
         sub_98196C(session, imageId, 24, 0, 8, 32, 1, height, get_current_rotation());
 
-        hasFence = track_paint_util_has_fence(EDGE_SW, position, mapElement, ride, get_current_rotation());
+        hasFence = track_paint_util_has_fence(EDGE_SW, position, tileElement, ride, get_current_rotation());
         if (hasFence) {
             imageId = SPR_STATION_PIER_FENCE_SW | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 31, 0, 1, 32, 7, height + 2, get_current_rotation());
         }
         track_paint_util_draw_station_covers(session, EDGE_SW, hasFence, entranceStyle, direction, height);
     } else {
-        hasFence = track_paint_util_has_fence(EDGE_NW, position, mapElement, ride, rotation);
+        hasFence = track_paint_util_has_fence(EDGE_NW, position, tileElement, ride, rotation);
         imageId = (hasFence ? SPR_STATION_PIER_EDGE_NW_FENCED : SPR_STATION_PIER_EDGE_NW) | session->TrackColours[SCHEME_SUPPORTS];
         sub_98197C(session, imageId, 0, 0, 32, 6, 1, height, 0, 2, height, rotation);
         track_paint_util_draw_station_covers(session, EDGE_NW, hasFence, entranceStyle, direction, height);
@@ -707,7 +707,7 @@ void track_paint_util_draw_pier(paint_session * session, Ride * ride, const rct_
         imageId = SPR_STATION_PIER_EDGE_SE | session->TrackColours[SCHEME_SUPPORTS];
         sub_98196C(session, imageId, 0, 24, 32, 8, 1, height, rotation);
 
-        hasFence = track_paint_util_has_fence(EDGE_SE, position, mapElement, ride, rotation);
+        hasFence = track_paint_util_has_fence(EDGE_SE, position, tileElement, ride, rotation);
         if (hasFence) {
             imageId = SPR_STATION_PIER_FENCE_SE | session->TrackColours[SCHEME_SUPPORTS];
             sub_98196C(session, imageId, 0, 31, 32, 1, 7, height + 2, rotation);
@@ -1620,7 +1620,7 @@ void track_paint_util_spinning_tunnel_paint(paint_session * session, sint8 thick
     }
 }
 
-void track_paint_util_onride_photo_small_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *mapElement)
+void track_paint_util_onride_photo_small_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *tileElement)
 {
     static const uint32 imageIds[4][3] =
     {
@@ -1630,7 +1630,7 @@ void track_paint_util_onride_photo_small_paint(paint_session * session, uint8 di
         { SPR_ON_RIDE_PHOTO_SIGN_SMALL_SE_NW, SPR_ON_RIDE_PHOTO_CAMERA_SMALL_E, SPR_ON_RIDE_PHOTO_CAMERA_FLASH_SMALL_E },
     };
 
-    bool takingPhoto = tile_element_is_taking_photo(mapElement);
+    bool takingPhoto = tile_element_is_taking_photo(tileElement);
     uint32 imageId = imageIds[direction][0] | session->TrackColours[SCHEME_MISC];
     uint32 flashImageId = imageIds[direction][takingPhoto ? 2 : 1] | session->TrackColours[SCHEME_MISC];
     switch (direction) {
@@ -1657,7 +1657,7 @@ void track_paint_util_onride_photo_small_paint(paint_session * session, uint8 di
     }
 }
 
-void track_paint_util_onride_photo_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *mapElement)
+void track_paint_util_onride_photo_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *tileElement)
 {
     static const uint32 imageIds[4][3] =
     {
@@ -1667,7 +1667,7 @@ void track_paint_util_onride_photo_paint(paint_session * session, uint8 directio
         { SPR_ON_RIDE_PHOTO_SIGN_SE_NW, SPR_ON_RIDE_PHOTO_CAMERA_E, SPR_ON_RIDE_PHOTO_CAMERA_FLASH_E },
     };
 
-    bool takingPhoto = tile_element_is_taking_photo(mapElement);
+    bool takingPhoto = tile_element_is_taking_photo(tileElement);
     uint32 imageId = imageIds[direction][0] | session->TrackColours[SCHEME_MISC];
     uint32 flashImageId = imageIds[direction][takingPhoto ? 2 : 1] | session->TrackColours[SCHEME_MISC];
     switch (direction) {
@@ -1733,9 +1733,9 @@ void track_paint_util_left_corkscrew_up_supports(paint_session * session, uint8
  *
  *  rct2: 0x006C4794
  */
-void track_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *mapElement)
+void track_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *tileElement)
 {
-    sint32 rideIndex = mapElement->properties.track.ride_index;
+    sint32 rideIndex = tileElement->properties.track.ride_index;
     Ride *ride = get_ride(rideIndex);
     if (ride->type == RIDE_TYPE_NULL) {
         log_error("Attempted to paint invalid ride: %d", rideIndex);
@@ -1752,9 +1752,9 @@ void track_paint(paint_session * session, uint8 direction, sint32 height, rct_ti
     rct_drawpixelinfo *dpi = session->Unk140E9A8;
 
     if (!gTrackDesignSaveMode || rideIndex == gTrackDesignSaveRideIndex) {
-        sint32 trackType = mapElement->properties.track.type;
-        sint32 trackSequence = tile_element_get_track_sequence(mapElement);
-        sint32 trackColourScheme = track_element_get_colour_scheme(mapElement);
+        sint32 trackType = tileElement->properties.track.type;
+        sint32 trackSequence = tile_element_get_track_sequence(tileElement);
+        sint32 trackColourScheme = track_element_get_colour_scheme(tileElement);
 
         if ((gCurrentViewportFlags & VIEWPORT_FLAG_TRACK_HEIGHTS) && dpi->zoom_level == 0) {
             session->InteractionType = VIEWPORT_INTERACTION_ITEM_NONE;
@@ -1772,13 +1772,13 @@ void track_paint(paint_session * session, uint8 direction, sint32 height, rct_ti
         session->TrackColours[SCHEME_SUPPORTS] = SPRITE_ID_PALETTE_COLOUR_1(ride->track_colour_supports[trackColourScheme]);
         session->TrackColours[SCHEME_MISC] = IMAGE_TYPE_REMAP;
         session->TrackColours[SCHEME_3] = 0x20C00000;
-        if (mapElement->type & TILE_ELEMENT_TYPE_FLAG_HIGHLIGHT) {
+        if (tileElement->type & TILE_ELEMENT_TYPE_FLAG_HIGHLIGHT) {
             session->TrackColours[SCHEME_TRACK] = 0x21600000;
             session->TrackColours[SCHEME_SUPPORTS] = 0x21600000;
             session->TrackColours[SCHEME_MISC] = 0x21600000;
             session->TrackColours[SCHEME_3] = 0x21600000;
         }
-        if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST) {
+        if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST) {
             uint32 ghost_id = construction_markers[gConfigGeneral.construction_marker_colour];
             session->InteractionType = VIEWPORT_INTERACTION_ITEM_NONE;
             session->TrackColours[SCHEME_TRACK] = ghost_id;
@@ -1795,7 +1795,7 @@ void track_paint(paint_session * session, uint8 direction, sint32 height, rct_ti
         if (paintFunctionGetter != NULL && !useOriginalRidePaint) {
             TRACK_PAINT_FUNCTION paintFunction = paintFunctionGetter(trackType, direction);
             if (paintFunction != NULL) {
-                paintFunction(session, rideIndex, trackSequence, direction, height, mapElement);
+                paintFunction(session, rideIndex, trackSequence, direction, height, tileElement);
             }
         }
         else {
@@ -1810,7 +1810,7 @@ void track_paint(paint_session * session, uint8 direction, sint32 height, rct_ti
                     (sint32)trackDirectionList,
                     direction,
                     height,
-                    (sint32)mapElement,
+                    (sint32)tileElement,
                     rideIndex * sizeof(Ride),
                     trackSequence
                 );
diff --git a/src/openrct2/ride/track_paint.h b/src/openrct2/ride/track_paint.h
index cd92bb7c1b..4c6f213334 100644
--- a/src/openrct2/ride/track_paint.h
+++ b/src/openrct2/ride/track_paint.h
@@ -267,18 +267,18 @@ extern bool gUseOriginalRidePaint;
 
 extern const size_t mini_golf_peep_animation_lengths[];
 
-bool track_paint_util_has_fence(enum edge_t edge, LocationXY16 position, rct_tile_element * mapElement, Ride * ride, uint8 rotation);
+bool track_paint_util_has_fence(enum edge_t edge, LocationXY16 position, rct_tile_element * tileElement, Ride * ride, uint8 rotation);
 void track_paint_util_paint_floor(paint_session * session, uint8 edges, uint32 colourFlags, uint16 height, const uint32 floorSprites[4], uint8 rotation);
-void track_paint_util_paint_fences(paint_session * session, uint8 edges, LocationXY16 position, rct_tile_element * mapElement, Ride * ride, uint32 colourFlags, uint16 height, const uint32 fenceSprites[4], uint8 rotation);
+void track_paint_util_paint_fences(paint_session * session, uint8 edges, LocationXY16 position, rct_tile_element * tileElement, Ride * ride, uint32 colourFlags, uint16 height, const uint32 fenceSprites[4], uint8 rotation);
 bool track_paint_util_draw_station_covers(paint_session * session, enum edge_t edge, bool hasFence, const rct_ride_entrance_definition * entranceStyle, uint8 direction, uint16 height);
 bool track_paint_util_draw_station_covers_2(paint_session * session, enum edge_t edge, bool hasFence, const rct_ride_entrance_definition * entranceStyle, uint8 direction, uint16 height, uint8 stationVariant);
-void track_paint_util_draw_station_platform(paint_session * session, Ride *ride, uint8 direction, sint32 height, sint32 zOffset, rct_tile_element * mapElement);
-void track_paint_util_draw_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element * mapElement);
-void track_paint_util_draw_station_2(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element * mapElement, sint32 fenceOffsetA, sint32 fenceOffsetB);
-void track_paint_util_draw_station_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_tile_element * mapElement);
-void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * mapElement, uint8 stationVariant);
+void track_paint_util_draw_station_platform(paint_session * session, Ride *ride, uint8 direction, sint32 height, sint32 zOffset, rct_tile_element * tileElement);
+void track_paint_util_draw_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element * tileElement);
+void track_paint_util_draw_station_2(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_tile_element * tileElement, sint32 fenceOffsetA, sint32 fenceOffsetB);
+void track_paint_util_draw_station_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_tile_element * tileElement);
+void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element * tileElement, uint8 stationVariant);
 bool track_paint_util_should_paint_supports(LocationXY16 position);
-void track_paint_util_draw_pier(paint_session * session, Ride * ride, const rct_ride_entrance_definition * entranceStyle, LocationXY16 position, uint8 direction, sint32 height, rct_tile_element * mapElement, uint8 rotation);
+void track_paint_util_draw_pier(paint_session * session, Ride * ride, const rct_ride_entrance_definition * entranceStyle, LocationXY16 position, uint8 direction, sint32 height, rct_tile_element * tileElement, uint8 rotation);
 void track_paint_util_draw_station_metal_supports(paint_session * session, uint8 direction, uint16 height, uint32 colour);
 void track_paint_util_draw_station_metal_supports_2(paint_session * session, uint8 direction, uint16 height, uint32 colour, uint8 type);
 
@@ -300,8 +300,8 @@ void track_paint_util_left_quarter_turn_3_tiles_paint_with_height_offset(paint_s
 void track_paint_util_left_quarter_turn_3_tiles_tunnel(paint_session * session, sint16 height, uint8 tunnelType, uint8 direction, uint8 trackSequence);
 void track_paint_util_left_quarter_turn_1_tile_paint(paint_session * session, sint8 thickness, sint16 height, sint16 boundBoxZOffset, sint32 direction, uint32 colourFlags, const uint32 * sprites, uint8 rotation);
 void track_paint_util_spinning_tunnel_paint(paint_session * session, sint8 thickness, sint16 height, uint8 direction, uint8 rotation);
-void track_paint_util_onride_photo_small_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *mapElement);
-void track_paint_util_onride_photo_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *mapElement);
+void track_paint_util_onride_photo_small_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *tileElement);
+void track_paint_util_onride_photo_paint(paint_session * session, uint8 direction, sint32 height, rct_tile_element *tileElement);
 void track_paint_util_right_helix_up_small_quarter_tiles_paint(paint_session * session, const sint8 thickness[2], sint16 height, sint32 direction, uint8 trackSequence, uint32 colourFlags, const uint32 sprites[4][3][2], const LocationXY16 offsets[4][3][2], const LocationXY16 boundsLengths[4][3][2], const LocationXYZ16 boundsOffsets[4][3][2], uint8 rotation);
 void track_paint_util_right_helix_up_large_quarter_tiles_paint(paint_session * session, const sint8 thickness[2], sint16 height, sint32 direction, uint8 trackSequence, uint32 colourFlags, const uint32 sprites[4][5][2], const LocationXY16 offsets[4][5][2], const LocationXY16 boundsLengths[4][5][2], const LocationXYZ16 boundsOffsets[4][5][2], uint8 rotation);
 void track_paint_util_eighth_to_diag_tiles_paint(paint_session * session, const sint8 thickness[4][4], sint16 height, sint32 direction, uint8 trackSequence, uint32 colourFlags, const uint32 sprites[4][4], const LocationXY16 offsets[4][4], const LocationXY16 boundsLengths[4][4], const LocationXYZ16 boundsOffsets[4][4], uint8 rotation);
@@ -314,7 +314,7 @@ void track_paint_util_right_vertical_loop_segments(paint_session * session, uint
 
 void track_paint_util_left_corkscrew_up_supports(paint_session * session, uint8 direction, uint16 height);
 
-typedef void (*TRACK_PAINT_FUNCTION)(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element* mapElement);
+typedef void (*TRACK_PAINT_FUNCTION)(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_tile_element* tileElement);
 typedef TRACK_PAINT_FUNCTION (*TRACK_PAINT_FUNCTION_GETTER)(sint32 trackType, sint32 direction);
 
 TRACK_PAINT_FUNCTION get_track_paint_function_stand_up_rc(sint32 trackType, sint32 direction);
diff --git a/src/openrct2/ride/transport/Chairlift.cpp b/src/openrct2/ride/transport/Chairlift.cpp
index 8d116795d5..514e87b2a6 100644
--- a/src/openrct2/ride/transport/Chairlift.cpp
+++ b/src/openrct2/ride/transport/Chairlift.cpp
@@ -117,78 +117,78 @@ static void chairlift_paint_util_draw_supports(paint_session * session, sint32 s
 static rct_tile_element * chairlift_paint_util_map_get_track_element_at_from_ride_fuzzy(sint32 x, sint32 y, sint32 z,
                                                                                        sint32 rideIndex)
 {
-    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
-    if (mapElement == NULL)
+    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
+    if (tileElement == NULL)
     {
         return NULL;
     }
 
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
-        if (mapElement->properties.track.ride_index != rideIndex)
+        if (tileElement->properties.track.ride_index != rideIndex)
             continue;
-        if (mapElement->base_height != z && mapElement->base_height != z - 1)
+        if (tileElement->base_height != z && tileElement->base_height != z - 1)
             continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 };
 
-static bool chairlift_paint_util_is_first_track(uint8 rideIndex, const rct_tile_element * mapElement, LocationXY16 pos,
+static bool chairlift_paint_util_is_first_track(uint8 rideIndex, const rct_tile_element * tileElement, LocationXY16 pos,
                                                 uint8 trackType)
 {
-    if (mapElement->properties.track.type != TRACK_ELEM_BEGIN_STATION)
+    if (tileElement->properties.track.type != TRACK_ELEM_BEGIN_STATION)
     {
         return false;
     }
 
-    LocationXY16 delta  = TileDirectionDelta[tile_element_get_direction(mapElement)];
+    LocationXY16 delta  = TileDirectionDelta[tile_element_get_direction(tileElement)];
     LocationXY16 newPos = {
         static_cast<sint16>(pos.x - delta.x),
         static_cast<sint16>(pos.y - delta.y),
     };
 
     rct_tile_element * nextTrack =
-        chairlift_paint_util_map_get_track_element_at_from_ride_fuzzy(newPos.x, newPos.y, mapElement->base_height, rideIndex);
+        chairlift_paint_util_map_get_track_element_at_from_ride_fuzzy(newPos.x, newPos.y, tileElement->base_height, rideIndex);
 
     return nextTrack == NULL;
 }
 
-static bool chairlift_paint_util_is_last_track(uint8 rideIndex, const rct_tile_element * mapElement, LocationXY16 pos,
+static bool chairlift_paint_util_is_last_track(uint8 rideIndex, const rct_tile_element * tileElement, LocationXY16 pos,
                                                uint8 trackType)
 {
-    if (mapElement->properties.track.type != TRACK_ELEM_END_STATION)
+    if (tileElement->properties.track.type != TRACK_ELEM_END_STATION)
     {
         return false;
     }
 
-    LocationXY16 delta  = TileDirectionDelta[tile_element_get_direction(mapElement)];
+    LocationXY16 delta  = TileDirectionDelta[tile_element_get_direction(tileElement)];
     LocationXY16 newPos = {
         static_cast<sint16>(pos.x + delta.x),
         static_cast<sint16>(pos.y + delta.y),
     };
 
     rct_tile_element * nextTrack =
-        chairlift_paint_util_map_get_track_element_at_from_ride_fuzzy(newPos.x, newPos.y, mapElement->base_height, rideIndex);
+        chairlift_paint_util_map_get_track_element_at_from_ride_fuzzy(newPos.x, newPos.y, tileElement->base_height, rideIndex);
 
     return nextTrack == NULL;
 }
 
 static void chairlift_paint_station_ne_sw(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     const LocationXY16 pos       = session->MapPosition;
-    uint8          trackType = mapElement->properties.track.type;
+    uint8          trackType = tileElement->properties.track.type;
     Ride *         ride      = get_ride(rideIndex);
     uint32         imageId;
 
-    bool isStart = chairlift_paint_util_is_first_track(rideIndex, mapElement, pos, trackType);
+    bool isStart = chairlift_paint_util_is_first_track(rideIndex, tileElement, pos, trackType);
     ;
-    bool isEnd = chairlift_paint_util_is_last_track(rideIndex, mapElement, pos, trackType);
+    bool isEnd = chairlift_paint_util_is_last_track(rideIndex, tileElement, pos, trackType);
 
     const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
 
@@ -203,7 +203,7 @@ static void chairlift_paint_station_ne_sw(paint_session * session, uint8 rideInd
     imageId = SPR_FLOOR_METAL | session->TrackColours[SCHEME_SUPPORTS];
     sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
 
-    bool hasFence = track_paint_util_has_fence(EDGE_NW, pos, mapElement, ride, get_current_rotation());
+    bool hasFence = track_paint_util_has_fence(EDGE_NW, pos, tileElement, ride, get_current_rotation());
     if (hasFence)
     {
         imageId = SPR_FENCE_METAL_NW | session->TrackColours[SCHEME_TRACK];
@@ -217,7 +217,7 @@ static void chairlift_paint_station_ne_sw(paint_session * session, uint8 rideInd
         sub_98199C(session, imageId, 0, 0, 1, 28, 7, height, 2, 2, height + 4, get_current_rotation());
     }
 
-    hasFence = track_paint_util_has_fence(EDGE_SE, pos, mapElement, ride, get_current_rotation());
+    hasFence = track_paint_util_has_fence(EDGE_SE, pos, tileElement, ride, get_current_rotation());
     if (hasFence)
     {
         imageId = SPR_FENCE_METAL_SE | session->TrackColours[SCHEME_TRACK];
@@ -270,16 +270,16 @@ static void chairlift_paint_station_ne_sw(paint_session * session, uint8 rideInd
 }
 
 static void chairlift_paint_station_se_nw(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     const LocationXY16 pos       = session->MapPosition;
-    uint8          trackType = mapElement->properties.track.type;
+    uint8          trackType = tileElement->properties.track.type;
     Ride *         ride      = get_ride(rideIndex);
     uint32         imageId;
 
-    bool isStart = chairlift_paint_util_is_first_track(rideIndex, mapElement, pos, trackType);
+    bool isStart = chairlift_paint_util_is_first_track(rideIndex, tileElement, pos, trackType);
     ;
-    bool isEnd = chairlift_paint_util_is_last_track(rideIndex, mapElement, pos, trackType);
+    bool isEnd = chairlift_paint_util_is_last_track(rideIndex, tileElement, pos, trackType);
 
     const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
 
@@ -294,7 +294,7 @@ static void chairlift_paint_station_se_nw(paint_session * session, uint8 rideInd
     imageId = SPR_FLOOR_METAL | session->TrackColours[SCHEME_SUPPORTS];
     sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
 
-    bool hasFence = track_paint_util_has_fence(EDGE_NE, pos, mapElement, ride, get_current_rotation());
+    bool hasFence = track_paint_util_has_fence(EDGE_NE, pos, tileElement, ride, get_current_rotation());
     if (hasFence)
     {
         imageId = SPR_FENCE_METAL_NE | session->TrackColours[SCHEME_TRACK];
@@ -308,7 +308,7 @@ static void chairlift_paint_station_se_nw(paint_session * session, uint8 rideInd
         sub_98199C(session, imageId, 0, 0, 28, 1, 7, height, 2, 2, height + 4, get_current_rotation());
     }
 
-    hasFence = track_paint_util_has_fence(EDGE_SW, pos, mapElement, ride, get_current_rotation());
+    hasFence = track_paint_util_has_fence(EDGE_SW, pos, tileElement, ride, get_current_rotation());
     if (hasFence)
     {
         imageId = SPR_FENCE_METAL_SW | session->TrackColours[SCHEME_TRACK];
@@ -363,20 +363,20 @@ static void chairlift_paint_station_se_nw(paint_session * session, uint8 rideInd
 
 /** rct2: 0x00744068 */
 static void chairlift_paint_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     if (direction % 2)
     {
-        chairlift_paint_station_se_nw(session, rideIndex, trackSequence, direction, height, mapElement);
+        chairlift_paint_station_se_nw(session, rideIndex, trackSequence, direction, height, tileElement);
     }
     else
     {
-        chairlift_paint_station_ne_sw(session, rideIndex, trackSequence, direction, height, mapElement);
+        chairlift_paint_station_ne_sw(session, rideIndex, trackSequence, direction, height, tileElement);
     }
 }
 
 static void chairlift_paint_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                 rct_tile_element * mapElement)
+                                 rct_tile_element * tileElement)
 {
     uint32 imageId;
     if (direction & 1)
@@ -398,7 +398,7 @@ static void chairlift_paint_flat(paint_session * session, uint8 rideIndex, uint8
 
 /** rct2: 0x00743FD8 */
 static void chairlift_paint_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -435,7 +435,7 @@ static void chairlift_paint_25_deg_up(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x00743FD8 */
 static void chairlift_paint_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -489,7 +489,7 @@ static void chairlift_paint_flat_to_25_deg_up(paint_session * session, uint8 rid
 
 /** rct2: 0x00743FF8 */
 static void chairlift_paint_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -543,28 +543,28 @@ static void chairlift_paint_25_deg_up_to_flat(paint_session * session, uint8 rid
 
 /** rct2: 0x00744008 */
 static void chairlift_paint_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                        sint32 height, rct_tile_element * mapElement)
+                                        sint32 height, rct_tile_element * tileElement)
 {
-    chairlift_paint_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    chairlift_paint_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x00744018 */
 static void chairlift_paint_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    chairlift_paint_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    chairlift_paint_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x00744028 */
 static void chairlift_paint_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
-    chairlift_paint_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    chairlift_paint_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x00744038 */
 static void chairlift_paint_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -630,9 +630,9 @@ static void chairlift_paint_left_quarter_turn_1_tile(paint_session * session, ui
 
 /** rct2: 0x00744048 */
 static void chairlift_paint_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    chairlift_paint_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
+    chairlift_paint_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 /* 0x008AAA0C */
diff --git a/src/openrct2/ride/transport/Lift.cpp b/src/openrct2/ride/transport/Lift.cpp
index 39e29d3f42..b9da66e781 100644
--- a/src/openrct2/ride/transport/Lift.cpp
+++ b/src/openrct2/ride/transport/Lift.cpp
@@ -54,7 +54,7 @@ static void paint_lift_cage(paint_session * session, sint8 index, uint32 colourF
 
 /** rct2: 0x0076C6CC */
 static void paint_lift_base(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                            rct_tile_element * mapElement)
+                            rct_tile_element * tileElement)
 {
     trackSequence = track_map_3x3[direction][trackSequence];
 
@@ -85,7 +85,7 @@ static void paint_lift_base(paint_session * session, uint8 rideIndex, uint8 trac
     uint32 imageId = SPR_FLOOR_METAL_B | session->TrackColours[SCHEME_SUPPORTS];
     sub_98197C(session, imageId, 0, 0, 32, 32, 1, height, 0, 0, height, get_current_rotation());
 
-    track_paint_util_paint_fences(session, edges, position, mapElement, ride, session->TrackColours[SCHEME_TRACK], height,
+    track_paint_util_paint_fences(session, edges, position, tileElement, ride, session->TrackColours[SCHEME_TRACK], height,
                                   fenceSpritesMetalB, get_current_rotation());
 
     sint32 blockedSegments = 0;
@@ -123,7 +123,7 @@ static void paint_lift_base(paint_session * session, uint8 rideIndex, uint8 trac
 
 /** rct2: 0x0076C6DC */
 static void paint_lift_tower_section(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
     if (trackSequence == 1)
     {
diff --git a/src/openrct2/ride/transport/MiniatureRailway.cpp b/src/openrct2/ride/transport/MiniatureRailway.cpp
index fb6e44ccbe..8e52fdd8ae 100644
--- a/src/openrct2/ride/transport/MiniatureRailway.cpp
+++ b/src/openrct2/ride/transport/MiniatureRailway.cpp
@@ -549,7 +549,7 @@ static const uint32 miniature_railway_track_pieces_diag_25_deg_up[4] = {
 
 /** rct2: 0x008AD0C0 */
 static void paint_miniature_railway_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
 
     bool isSupported =
@@ -578,7 +578,7 @@ static void paint_miniature_railway_track_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x008AD170, 0x008AD180, 0x008AD190 */
 static void paint_miniature_railway_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -592,7 +592,7 @@ static void paint_miniature_railway_station(paint_session * session, uint8 rideI
 
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
 
-    track_paint_util_draw_station_3(session, rideIndex, trackSequence, direction, height + 2, height, mapElement);
+    track_paint_util_draw_station_3(session, rideIndex, trackSequence, direction, height + 2, height, tileElement);
     // covers shouldn't be offset by +2
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -601,7 +601,7 @@ static void paint_miniature_railway_station(paint_session * session, uint8 rideI
 
 /** rct2: 0x008AD0D0 */
 static void paint_miniature_railway_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
 
     uint32 imageId = miniature_railway_track_pieces_25_deg_up[direction] | session->TrackColours[SCHEME_TRACK];
@@ -632,7 +632,7 @@ static void paint_miniature_railway_track_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x008AD0E0 */
 static void paint_miniature_railway_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
 
     uint32 imageId = miniature_railway_track_pieces_flat_to_25_deg_up[direction] | session->TrackColours[SCHEME_TRACK];
@@ -663,7 +663,7 @@ static void paint_miniature_railway_track_flat_to_25_deg_up(paint_session * sess
 
 /** rct2: 0x008AD0F0 */
 static void paint_miniature_railway_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
 
     uint32 imageId = miniature_railway_track_pieces_25_deg_up_to_flat[direction] | session->TrackColours[SCHEME_TRACK];
@@ -694,23 +694,23 @@ static void paint_miniature_railway_track_25_deg_up_to_flat(paint_session * sess
 
 /** rct2: 0x008AD100 */
 static void paint_miniature_railway_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_miniature_railway_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_miniature_railway_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008AD110 */
 static void paint_miniature_railway_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_miniature_railway_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_miniature_railway_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008AD120 */
 static void paint_miniature_railway_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_miniature_railway_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_miniature_railway_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 const LocationXY16 miniature_railway_right_quarter_turn_5_tiles_offsets[4][5] = { {
@@ -820,7 +820,7 @@ static const sint8 miniature_railway_right_quarter_turn_5_tiles_sprite_map[] = {
 /** rct2: 0x008AD140 */
 static void paint_miniature_railway_track_right_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
 
     if (right_quarter_turn_5_supports_type[direction][trackSequence] != -1)
@@ -908,11 +908,11 @@ static void paint_miniature_railway_track_right_quarter_turn_5_tiles(paint_sessi
 /** rct2: 0x008AD130 */
 static void paint_miniature_railway_track_left_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
     paint_miniature_railway_track_right_quarter_turn_5_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 static const sint8 s_bend_left_supports_type[4][4] = { { 0, 5, 3, 0 }, { 1, 2, 4, 1 }, { 0, 5, 3, 0 }, { 1, 2, 4, 1 } };
@@ -928,7 +928,7 @@ static const uint32 miniature_railway_s_bend_left_tiles_track_floor[2][4] = { {
 
 /** rct2: 0x8AD150 */
 static void paint_miniature_railway_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
@@ -1022,7 +1022,7 @@ static const uint32 miniature_railway_s_bend_right_tiles_track_floor[2][4] = { {
 
 /** rct2: 0x008AD160 */
 static void paint_miniature_railway_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
@@ -1148,7 +1148,7 @@ const LocationXYZ16 miniature_railway_right_quarter_turn_3_tile_bound_offsets[4]
 /** rct2: 0x008AD1B0 */
 static void paint_miniature_railway_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     bool isSupported = false;
     if (trackSequence != 1 && trackSequence != 2)
@@ -1207,11 +1207,11 @@ static void paint_miniature_railway_track_right_quarter_turn_3_tiles(paint_sessi
 /** rct2: 0x008AD1A0 */
 static void paint_miniature_railway_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
     paint_miniature_railway_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                             mapElement);
+                                                             tileElement);
 }
 
 static const sint8 paint_miniature_railway_eighth_to_diag_index[] = { 0, 1, 2, -1, 3 };
@@ -1289,12 +1289,12 @@ static const LocationXY16 miniature_railway_track_floor_pieces_left_eight_to_dia
 
 /** rct2: 0x008AD1C0 */
 static void paint_miniature_railway_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint8 supportType[4][5] = { { 0, 0, 3, 5, 1 }, { 1, 1, 4, 2, 0 }, { 0, 0, 5, 3, 1 }, { 1, 1, 2, 4, 0 } };
 
     bool isSupported           = false;
-    bool isRightEighthToOrthog = mapElement->properties.track.type == TRACK_ELEM_RIGHT_EIGHTH_TO_ORTHOGONAL;
+    bool isRightEighthToOrthog = tileElement->properties.track.type == TRACK_ELEM_RIGHT_EIGHTH_TO_ORTHOGONAL;
     // Right eighth to orthogonal calls this function but we do not want to have a support call for it
     // for track sequence 4
     if (trackSequence != 4 || !isRightEighthToOrthog)
@@ -1427,12 +1427,12 @@ static const LocationXY16 miniature_railway_track_floor_pieces_right_eight_to_di
 
 /** rct2: 0x008AD1D0 */
 static void paint_miniature_railway_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint8 supportType[4][5] = { { 0, 0, 2, 4, 1 }, { 1, 1, 3, 5, 0 }, { 0, 0, 4, 2, 1 }, { 1, 1, 5, 3, 0 } };
 
     bool isSupported          = false;
-    bool isLeftEighthToOrthog = mapElement->properties.track.type == TRACK_ELEM_LEFT_EIGHTH_TO_ORTHOGONAL;
+    bool isLeftEighthToOrthog = tileElement->properties.track.type == TRACK_ELEM_LEFT_EIGHTH_TO_ORTHOGONAL;
     // Right eighth to orthogonal calls this function but we do not want to have a support call for it
     // for track sequence 4
     if (trackSequence != 4 || !isLeftEighthToOrthog)
@@ -1497,21 +1497,21 @@ static void paint_miniature_railway_track_right_eighth_to_diag(paint_session * s
 /** rct2: 0x008AD1E0 */
 static void paint_miniature_railway_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex,
                                                                     uint8 trackSequence, uint8 direction, sint32 height,
-                                                                    rct_tile_element * mapElement)
+                                                                    rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     paint_miniature_railway_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) % 4, height,
-                                                       mapElement);
+                                                       tileElement);
 }
 
 /** rct2: 0x008AD1F0 */
 static void paint_miniature_railway_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex,
                                                                      uint8 trackSequence, uint8 direction, sint32 height,
-                                                                     rct_tile_element * mapElement)
+                                                                     rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
     paint_miniature_railway_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 static const bool miniature_railway_diag_image_segment[][4] = {
@@ -1556,7 +1556,7 @@ static const floor_desc floors[] = {
 
 /** rct2: 0x008AD200 */
 static void miniature_railway_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     bool   isSupported = false;
     sint16 supportType = monorail_diag_support_types[direction][trackSequence];
@@ -1625,7 +1625,7 @@ static bool wooden_supports_paint_setup(paint_session * session, sint32 woodType
 
 /** rct2: 0x008AD230 */
 static void miniature_railway_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     // TODO: The supports are inconsistent for different rotations
 
@@ -1697,7 +1697,7 @@ static void miniature_railway_track_diag_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x008AD210 */
 static void miniature_railway_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bool hasSupports = false;
 
@@ -1745,7 +1745,7 @@ static void miniature_railway_track_diag_flat_to_25_deg_up(paint_session * sessi
 
 /** rct2: 0x008AD220 */
 static void miniature_railway_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const sint8 supportOffsets[][4] = {
         { 0, +8, +8, +8 },
@@ -1817,7 +1817,7 @@ static void miniature_railway_track_diag_25_deg_up_to_flat(paint_session * sessi
 
 /** rct2: 0x008AD260 */
 static void miniature_railway_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const sint8 supportOffsets[][4] = {
         { 0, +16, +16, 0 },
@@ -1888,7 +1888,7 @@ static void miniature_railway_track_diag_25_deg_down(paint_session * session, ui
 
 /** rct2: 0x008AD240 */
 static void miniature_railway_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const sint8 supportOffsets[][4] = {
         { 0, +16, +16, 0 },
@@ -1957,7 +1957,7 @@ static void miniature_railway_track_diag_flat_to_25_deg_down(paint_session * ses
 }
 
 static void miniature_railway_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     bool     hasSupports      = false;
     uint32   floorImage       = 0;
diff --git a/src/openrct2/ride/transport/Monorail.cpp b/src/openrct2/ride/transport/Monorail.cpp
index 83e8fe60a8..4199b79d47 100644
--- a/src/openrct2/ride/transport/Monorail.cpp
+++ b/src/openrct2/ride/transport/Monorail.cpp
@@ -426,7 +426,7 @@ static const uint32 monorail_track_pieces_diag_25_deg_up[4] = {
 
 /** rct2: 0x008AE1AC */
 static void paint_monorail_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                      sint32 height, rct_tile_element * mapElement)
+                                      sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -462,7 +462,7 @@ static void paint_monorail_track_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008AE25C, 0x008AE26C, 0x008AE27C */
 static void paint_monorail_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -507,7 +507,7 @@ static void paint_monorail_station(paint_session * session, uint8 rideIndex, uin
         metal_a_supports_paint_setup(session, METAL_SUPPORTS_BOXED, 7, 0, height, session->TrackColours[SCHEME_SUPPORTS]);
     }
 
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
 
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
     paint_util_set_general_support_height(session, height + 32, 0x20);
@@ -515,7 +515,7 @@ static void paint_monorail_station(paint_session * session, uint8 rideIndex, uin
 
 /** rct2: 0x008AE1BC */
 static void paint_monorail_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -558,7 +558,7 @@ static void paint_monorail_track_25_deg_up(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008AE1CC */
 static void paint_monorail_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -601,7 +601,7 @@ static void paint_monorail_track_flat_to_25_deg_up(paint_session * session, uint
 
 /** rct2: 0x008AE1DC */
 static void paint_monorail_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position = session->MapPosition;
 
@@ -644,28 +644,28 @@ static void paint_monorail_track_25_deg_up_to_flat(paint_session * session, uint
 
 /** rct2: 0x008AE1EC */
 static void paint_monorail_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    paint_monorail_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_monorail_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008AE1FC */
 static void paint_monorail_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_monorail_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_monorail_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008AE20C */
 static void paint_monorail_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_monorail_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_monorail_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008AE22C */
 static void paint_monorail_track_right_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_5_tiles_paint(
         session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -727,15 +727,15 @@ static void paint_monorail_track_right_quarter_turn_5_tiles(paint_session * sess
 
 /** rct2: 0x008AE21C */
 static void paint_monorail_track_left_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    paint_monorail_track_right_quarter_turn_5_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    paint_monorail_track_right_quarter_turn_5_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 /** rct2: 0x */
 static void paint_monorail_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
@@ -832,7 +832,7 @@ static void paint_monorail_track_s_bend_left(paint_session * session, uint8 ride
 
 /** rct2: 0x008AE24C */
 static void paint_monorail_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     if (direction == 2 || direction == 3)
     {
@@ -929,7 +929,7 @@ static void paint_monorail_track_s_bend_right(paint_session * session, uint8 rid
 
 /** rct2: 0x008AE29C */
 static void paint_monorail_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_3_tiles_paint(
         session, 3, height, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -965,17 +965,17 @@ static void paint_monorail_track_right_quarter_turn_3_tiles(paint_session * sess
 
 /** rct2: 0x008AE28C */
 static void paint_monorail_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    paint_monorail_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    paint_monorail_track_right_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 static const sint8 paint_monorail_eighth_to_diag_index[] = { 0, 1, 2, -1, 3 };
 
 /** rct2: 0x008AE31C */
 static void paint_monorail_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                     uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                     uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     sint8 index = paint_monorail_eighth_to_diag_index[trackSequence];
     if (index >= 0)
@@ -1038,7 +1038,7 @@ static void paint_monorail_track_left_eighth_to_diag(paint_session * session, ui
 
 /** rct2: 0x008AE32C */
 static void paint_monorail_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     sint8 index = paint_monorail_eighth_to_diag_index[trackSequence];
     if (index >= 0)
@@ -1101,20 +1101,20 @@ static void paint_monorail_track_right_eighth_to_diag(paint_session * session, u
 
 /** rct2: 0x008AE33C */
 static void paint_monorail_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint8 map[] = { 4, 2, 3, 1, 0 };
     trackSequence     = map[trackSequence];
-    paint_monorail_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    paint_monorail_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 /** rct2: 0x008AE34C */
 static void paint_monorail_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     const uint8 map[] = { 4, 2, 3, 1, 0 };
     trackSequence     = map[trackSequence];
-    paint_monorail_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
+    paint_monorail_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 static const bool monorail_diag_image_segment[][4] =
@@ -1134,7 +1134,7 @@ static const sint32 monorail_diag_blocked_segments[] = { SEGMENT_C4 | SEGMENT_CC
 
 /** rct2: 0x008AE2AC */
 static void paint_monorail_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     if (monorail_diag_image_segment[direction][trackSequence])
     {
@@ -1155,7 +1155,7 @@ static void paint_monorail_track_diag_flat(paint_session * session, uint8 rideIn
 
 /** rct2: 0x008AE2DC */
 static void paint_monorail_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     if (monorail_diag_image_segment[direction][trackSequence])
     {
@@ -1176,7 +1176,7 @@ static void paint_monorail_track_diag_25_deg_up(paint_session * session, uint8 r
 
 /** rct2: 0x008AE2BC */
 static void paint_monorail_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (monorail_diag_image_segment[direction][trackSequence])
     {
@@ -1197,7 +1197,7 @@ static void paint_monorail_track_diag_flat_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x008AE2CC */
 static void paint_monorail_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                        uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                        uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (monorail_diag_image_segment[direction][trackSequence])
     {
@@ -1218,7 +1218,7 @@ static void paint_monorail_track_diag_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x008AE30C */
 static void paint_monorail_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (monorail_diag_image_segment[direction][trackSequence])
     {
@@ -1239,7 +1239,7 @@ static void paint_monorail_track_diag_25_deg_down(paint_session * session, uint8
 
 /** rct2: 0x008AE2EC */
 static void paint_monorail_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (monorail_diag_image_segment[direction][trackSequence])
     {
@@ -1261,7 +1261,7 @@ static void paint_monorail_track_diag_flat_to_25_deg_down(paint_session * sessio
 
 /** rct2: 0x008AE2FC */
 static void paint_monorail_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     if (monorail_diag_image_segment[direction][trackSequence])
     {
diff --git a/src/openrct2/ride/transport/SuspendedMonorail.cpp b/src/openrct2/ride/transport/SuspendedMonorail.cpp
index 9d74d4dc31..84d7fd2053 100644
--- a/src/openrct2/ride/transport/SuspendedMonorail.cpp
+++ b/src/openrct2/ride/transport/SuspendedMonorail.cpp
@@ -28,7 +28,7 @@
 
 /** rct2: 0x008636F4 */
 static void suspended_monorail_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -57,7 +57,7 @@ static void suspended_monorail_track_flat(paint_session * session, uint8 rideInd
 
 /** rct2: 0x008637A4, 0x008637B4, 0x008637C4 */
 static void suspended_monorail_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_STATION_BASE_C_SW_NE, 25853, SPR_STATION_INVERTED_BAR_F_SW_NE },
@@ -73,7 +73,7 @@ static void suspended_monorail_track_station(paint_session * session, uint8 ride
     sub_98199C_rotated(session, direction, imageIds[direction][2] | session->TrackColours[SCHEME_SUPPORTS], 0, 6, 32, 20, 3,
                        height + 32, 0, 6, height + 32);
     track_paint_util_draw_station_metal_supports_2(session, direction, height, session->TrackColours[SCHEME_SUPPORTS], 3);
-    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, mapElement,
+    track_paint_util_draw_station_inverted(session, rideIndex, trackSequence, direction, height, tileElement,
                                            STATION_VARIANT_TALL);
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_9);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -82,7 +82,7 @@ static void suspended_monorail_track_station(paint_session * session, uint8 ride
 
 /** rct2: 0x00863704 */
 static void suspended_monorail_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -142,7 +142,7 @@ static void suspended_monorail_track_25_deg_up(paint_session * session, uint8 ri
 
 /** rct2: 0x00863714 */
 static void suspended_monorail_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -202,7 +202,7 @@ static void suspended_monorail_track_flat_to_25_deg_up(paint_session * session,
 
 /** rct2: 0x00863724 */
 static void suspended_monorail_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (direction)
     {
@@ -262,28 +262,28 @@ static void suspended_monorail_track_25_deg_up_to_flat(paint_session * session,
 
 /** rct2: 0x00863734 */
 static void suspended_monorail_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    suspended_monorail_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    suspended_monorail_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00863744 */
 static void suspended_monorail_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    suspended_monorail_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    suspended_monorail_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00863754 */
 static void suspended_monorail_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    suspended_monorail_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    suspended_monorail_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00863764 */
 static void suspended_monorail_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -438,15 +438,15 @@ static void suspended_monorail_track_left_quarter_turn_5(paint_session * session
 
 /** rct2: 0x00863774 */
 static void suspended_monorail_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    suspended_monorail_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    suspended_monorail_track_left_quarter_turn_5(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00863784 */
 static void suspended_monorail_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -596,7 +596,7 @@ static void suspended_monorail_track_s_bend_left(paint_session * session, uint8
 
 /** rct2: 0x00863794 */
 static void suspended_monorail_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -746,7 +746,7 @@ static void suspended_monorail_track_s_bend_right(paint_session * session, uint8
 
 /** rct2: 0x008637D4 */
 static void suspended_monorail_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -850,15 +850,15 @@ static void suspended_monorail_track_left_quarter_turn_3(paint_session * session
 
 /** rct2: 0x008637E4 */
 static void suspended_monorail_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    suspended_monorail_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);
+    suspended_monorail_track_left_quarter_turn_3(session, rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);
 }
 
 /** rct2: 0x00863864 */
 static void suspended_monorail_track_left_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1001,7 +1001,7 @@ static void suspended_monorail_track_left_eighth_to_diag(paint_session * session
 
 /** rct2: 0x00863874 */
 static void suspended_monorail_track_right_eighth_to_diag(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1144,23 +1144,23 @@ static void suspended_monorail_track_right_eighth_to_diag(paint_session * sessio
 
 /** rct2: 0x00863884 */
 static void suspended_monorail_track_left_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    suspended_monorail_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    suspended_monorail_track_right_eighth_to_diag(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 /** rct2: 0x00863894 */
 static void suspended_monorail_track_right_eighth_to_orthogonal(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];
-    suspended_monorail_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);
+    suspended_monorail_track_left_eighth_to_diag(session, rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);
 }
 
 /** rct2: 0x008637F4 */
 static void suspended_monorail_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1238,7 +1238,7 @@ static void suspended_monorail_track_diag_flat(paint_session * session, uint8 ri
 
 /** rct2: 0x00863824 */
 static void suspended_monorail_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1316,7 +1316,7 @@ static void suspended_monorail_track_diag_25_deg_up(paint_session * session, uin
 
 /** rct2: 0x00863804 */
 static void suspended_monorail_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1394,7 +1394,7 @@ static void suspended_monorail_track_diag_flat_to_25_deg_up(paint_session * sess
 
 /** rct2: 0x00863814 */
 static void suspended_monorail_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1472,7 +1472,7 @@ static void suspended_monorail_track_diag_25_deg_up_to_flat(paint_session * sess
 
 /** rct2: 0x00863854 */
 static void suspended_monorail_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1550,7 +1550,7 @@ static void suspended_monorail_track_diag_25_deg_down(paint_session * session, u
 
 /** rct2: 0x00863834 */
 static void suspended_monorail_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
@@ -1625,7 +1625,7 @@ static void suspended_monorail_track_diag_flat_to_25_deg_down(paint_session * se
 
 /** rct2: 0x00863844 */
 static void suspended_monorail_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     switch (trackSequence)
     {
diff --git a/src/openrct2/ride/water/BoatRide.cpp b/src/openrct2/ride/water/BoatRide.cpp
index 0764520fce..41efd3ea6c 100644
--- a/src/openrct2/ride/water/BoatRide.cpp
+++ b/src/openrct2/ride/water/BoatRide.cpp
@@ -38,7 +38,7 @@ enum
 
 /** rct2: 0x008B0E40 */
 static void paint_boat_ride_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -66,7 +66,7 @@ static void paint_boat_ride_track_flat(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x008B0E50 */
 static void paint_boat_ride_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16                             position      = session->MapPosition;
     Ride *                               ride          = get_ride(rideIndex);
@@ -75,13 +75,13 @@ static void paint_boat_ride_station(paint_session * session, uint8 rideIndex, ui
     if (direction & 1)
     {
         paint_util_push_tunnel_right(session, height, TUNNEL_6);
-        track_paint_util_draw_pier(session, ride, entranceStyle, position, direction, height, mapElement,
+        track_paint_util_draw_pier(session, ride, entranceStyle, position, direction, height, tileElement,
                                    get_current_rotation());
     }
     else
     {
         paint_util_push_tunnel_left(session, height, TUNNEL_6);
-        track_paint_util_draw_pier(session, ride, entranceStyle, position, direction, height, mapElement,
+        track_paint_util_draw_pier(session, ride, entranceStyle, position, direction, height, tileElement,
                                    get_current_rotation());
     }
 
@@ -91,7 +91,7 @@ static void paint_boat_ride_station(paint_session * session, uint8 rideIndex, ui
 
 /** rct2: 0x008B0E80 */
 static void paint_boat_ride_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
     switch (direction)
@@ -133,9 +133,9 @@ static void paint_boat_ride_track_left_quarter_turn_1_tile(paint_session * sessi
 
 /** rct2: 0x008B0E90 */
 static void paint_boat_ride_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_boat_ride_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, mapElement);
+    paint_boat_ride_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height, tileElement);
 }
 
 /**
diff --git a/src/openrct2/ride/water/DingySlide.cpp b/src/openrct2/ride/water/DingySlide.cpp
index 87181ca526..22e89fa0dc 100644
--- a/src/openrct2/ride/water/DingySlide.cpp
+++ b/src/openrct2/ride/water/DingySlide.cpp
@@ -357,7 +357,7 @@ enum
 };
 
 static void dinghy_slide_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                    sint32 height, rct_tile_element * mapElement)
+                                    sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][2] = {
         {
@@ -374,7 +374,7 @@ static void dinghy_slide_track_flat(paint_session * session, uint8 rideIndex, ui
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[isChained][direction][0] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 2, height, 0, 6, height);
 
@@ -394,7 +394,7 @@ static void dinghy_slide_track_flat(paint_session * session, uint8 rideIndex, ui
 }
 
 static void dinghy_slide_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_STATION_SW_NE, SPR_STATION_BASE_B_SW_NE },
@@ -413,7 +413,7 @@ static void dinghy_slide_track_station(paint_session * session, uint8 rideIndex,
     metal_a_supports_paint_setup(session, METAL_SUPPORTS_TUBES, 8 - (direction & 1), 0, height,
                                  session->TrackColours[SCHEME_SUPPORTS]);
 
-    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, mapElement);
+    track_paint_util_draw_station(session, rideIndex, trackSequence, direction, height, tileElement);
 
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
 
@@ -422,7 +422,7 @@ static void dinghy_slide_track_station(paint_session * session, uint8 rideIndex,
 }
 
 static void dinghy_slide_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][2] = {
         {
@@ -439,7 +439,7 @@ static void dinghy_slide_track_25_deg_up(paint_session * session, uint8 rideInde
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[isChained][direction][0] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 2, height, 0, 6, height);
 
@@ -466,7 +466,7 @@ static void dinghy_slide_track_25_deg_up(paint_session * session, uint8 rideInde
 }
 
 static void dinghy_slide_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                         sint32 height, rct_tile_element * mapElement)
+                                         sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_60_DEG_SW_NE, SPR_DINGHY_SLIDE_60_DEG_FRONT_SW_NE },
@@ -501,7 +501,7 @@ static void dinghy_slide_track_60_deg_up(paint_session * session, uint8 rideInde
 }
 
 static void dinghy_slide_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][2] = {
         {
@@ -518,7 +518,7 @@ static void dinghy_slide_track_flat_to_25_deg_up(paint_session * session, uint8
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[isChained][direction][0] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 2, height, 0, 6, height);
 
@@ -545,7 +545,7 @@ static void dinghy_slide_track_flat_to_25_deg_up(paint_session * session, uint8
 }
 
 static void dinghy_slide_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_25_DEG_TO_60_DEG_SW_NE, SPR_DINGHY_SLIDE_25_DEG_TO_60_DEG_FRONT_SW_NE },
@@ -580,7 +580,7 @@ static void dinghy_slide_track_25_deg_up_to_60_deg_up(paint_session * session, u
 }
 
 static void dinghy_slide_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_60_DEG_TO_25_DEG_SW_NE, SPR_DINGHY_SLIDE_60_DEG_TO_25_DEG_FRONT_SW_NE },
@@ -615,7 +615,7 @@ static void dinghy_slide_track_60_deg_up_to_25_deg_up(paint_session * session, u
 }
 
 static void dinghy_slide_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[2][4][2] = {
         {
@@ -632,7 +632,7 @@ static void dinghy_slide_track_25_deg_up_to_flat(paint_session * session, uint8
         },
     };
 
-    uint8  isChained = track_element_is_lift_hill(mapElement) ? 1 : 0;
+    uint8  isChained = track_element_is_lift_hill(tileElement) ? 1 : 0;
     uint32 imageId   = imageIds[isChained][direction][0] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 2, height, 0, 6, height);
 
@@ -659,37 +659,37 @@ static void dinghy_slide_track_25_deg_up_to_flat(paint_session * session, uint8
 }
 
 static void dinghy_slide_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_right_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][5] = {
         {
@@ -814,20 +814,20 @@ static void dinghy_slide_track_right_quarter_turn_5(paint_session * session, uin
 }
 
 static void dinghy_slide_track_left_quarter_turn_5(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    dinghy_slide_track_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    dinghy_slide_track_right_quarter_turn_5(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 static void dinghy_slide_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                          uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                          uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4][2] = {
         { { SPR_DINGHY_SLIDE_S_BEND_SW_SE_SW_SEQ_3, SPR_DINGHY_SLIDE_S_BEND_FRONT_NE_NW_NE_SEQ_0 },
@@ -917,7 +917,7 @@ static void dinghy_slide_track_s_bend_left(paint_session * session, uint8 rideIn
 }
 
 static void dinghy_slide_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4][2] = {
         { { SPR_DINGHY_SLIDE_S_BEND_SW_NW_SW_SEQ_3, SPR_DINGHY_SLIDE_S_BEND_FRONT_NE_SE_NE_SEQ_0 },
@@ -1007,7 +1007,7 @@ static void dinghy_slide_track_s_bend_right(paint_session * session, uint8 rideI
 }
 
 static void dinghy_slide_track_right_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][3] = {
         {
@@ -1087,14 +1087,14 @@ static void dinghy_slide_track_right_quarter_turn_3(paint_session * session, uin
 }
 
 static void dinghy_slide_track_left_quarter_turn_3(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    dinghy_slide_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    dinghy_slide_track_right_quarter_turn_3(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 static void dinghy_slide_track_flat_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_FLAT_COVERED_SW_NE, SPR_DINGHY_SLIDE_FLAT_COVERED_FRONT_SW_NE },
@@ -1122,7 +1122,7 @@ static void dinghy_slide_track_flat_covered(paint_session * session, uint8 rideI
 }
 
 static void dinghy_slide_track_25_deg_up_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_25_DEG_COVERED_SW_NE, SPR_DINGHY_SLIDE_25_DEG_COVERED_FRONT_SW_NE },
@@ -1157,7 +1157,7 @@ static void dinghy_slide_track_25_deg_up_covered(paint_session * session, uint8
 }
 
 static void dinghy_slide_track_60_deg_up_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_60_DEG_COVERED_SW_NE, SPR_DINGHY_SLIDE_60_DEG_COVERED_FRONT_SW_NE },
@@ -1192,7 +1192,7 @@ static void dinghy_slide_track_60_deg_up_covered(paint_session * session, uint8
 }
 
 static void dinghy_slide_track_flat_to_25_deg_up_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_FLAT_TO_25_DEG_COVERED_SW_NE, SPR_DINGHY_SLIDE_FLAT_TO_25_DEG_COVERED_FRONT_SW_NE },
@@ -1227,7 +1227,7 @@ static void dinghy_slide_track_flat_to_25_deg_up_covered(paint_session * session
 }
 
 static void dinghy_slide_track_25_deg_up_to_60_deg_up_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_25_DEG_TO_60_DEG_COVERED_SW_NE, SPR_DINGHY_SLIDE_25_DEG_TO_60_DEG_COVERED_FRONT_SW_NE },
@@ -1262,7 +1262,7 @@ static void dinghy_slide_track_25_deg_up_to_60_deg_up_covered(paint_session * se
 }
 
 static void dinghy_slide_track_60_deg_up_to_25_deg_up_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_60_DEG_TO_25_DEG_COVERED_SW_NE, SPR_DINGHY_SLIDE_60_DEG_TO_25_DEG_COVERED_FRONT_SW_NE },
@@ -1297,7 +1297,7 @@ static void dinghy_slide_track_60_deg_up_to_25_deg_up_covered(paint_session * se
 }
 
 static void dinghy_slide_track_25_deg_up_to_flat_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_DINGHY_SLIDE_25_DEG_TO_FLAT_COVERED_SW_NE, SPR_DINGHY_SLIDE_25_DEG_TO_FLAT_COVERED_FRONT_SW_NE },
@@ -1332,38 +1332,38 @@ static void dinghy_slide_track_25_deg_up_to_flat_covered(paint_session * session
 }
 
 static void dinghy_slide_track_25_deg_down_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_25_deg_up_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_25_deg_up_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_60_deg_down_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_60_deg_up_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_60_deg_up_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_flat_to_25_deg_down_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_25_deg_up_to_flat_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_25_deg_up_to_flat_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_25_deg_down_to_60_deg_down_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     dinghy_slide_track_60_deg_up_to_25_deg_up_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 static void dinghy_slide_track_25_deg_down_to_flat_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    dinghy_slide_track_flat_to_25_deg_up_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    dinghy_slide_track_flat_to_25_deg_up_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void dinghy_slide_track_right_quarter_turn_5_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][5] = {
         {
@@ -1488,14 +1488,14 @@ static void dinghy_slide_track_right_quarter_turn_5_covered(paint_session * sess
 }
 
 static void dinghy_slide_track_left_quarter_turn_5_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];
-    dinghy_slide_track_right_quarter_turn_5_covered(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    dinghy_slide_track_right_quarter_turn_5_covered(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 static void dinghy_slide_track_s_bend_left_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4][2] = {
         { { SPR_DINGHY_SLIDE_S_BEND_COVERED_SW_SE_SW_SEQ_3, SPR_DINGHY_SLIDE_S_BEND_COVERED_FRONT_NE_NW_NE_SEQ_0 },
@@ -1585,7 +1585,7 @@ static void dinghy_slide_track_s_bend_left_covered(paint_session * session, uint
 }
 
 static void dinghy_slide_track_s_bend_right_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4][2] = {
         { { SPR_DINGHY_SLIDE_S_BEND_COVERED_SW_NW_SW_SEQ_3, SPR_DINGHY_SLIDE_S_BEND_COVERED_FRONT_NE_SE_NE_SEQ_0 },
@@ -1675,7 +1675,7 @@ static void dinghy_slide_track_s_bend_right_covered(paint_session * session, uin
 }
 
 static void dinghy_slide_track_right_quarter_turn_3_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const sprite_bb imageIds[4][3] = {
         {
@@ -1755,17 +1755,17 @@ static void dinghy_slide_track_right_quarter_turn_3_covered(paint_session * sess
 }
 
 static void dinghy_slide_track_left_quarter_turn_3_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];
-    dinghy_slide_track_right_quarter_turn_3_covered(session, rideIndex, trackSequence, (direction + 1) % 4, height, mapElement);
+    dinghy_slide_track_right_quarter_turn_3_covered(session, rideIndex, trackSequence, (direction + 1) % 4, height, tileElement);
 }
 
 static void dinghy_slide_track_60_deg_down_to_25_deg_down_covered(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     dinghy_slide_track_25_deg_up_to_60_deg_up_covered(session, rideIndex, trackSequence, (direction + 2) & 3, height,
-                                                      mapElement);
+                                                      tileElement);
 }
 
 TRACK_PAINT_FUNCTION get_track_paint_function_dinghy_slide(sint32 trackType, sint32 direction)
diff --git a/src/openrct2/ride/water/LogFlume.cpp b/src/openrct2/ride/water/LogFlume.cpp
index e8bc30b9a1..891b4ca309 100644
--- a/src/openrct2/ride/water/LogFlume.cpp
+++ b/src/openrct2/ride/water/LogFlume.cpp
@@ -169,7 +169,7 @@ static const uint32 LogFlumeTrackFlatImageIds[4][2] = {
 };
 
 static void paint_log_flume_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = LogFlumeTrackFlatImageIds[direction][0] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = LogFlumeTrackFlatImageIds[direction][1] | session->TrackColours[SCHEME_TRACK];
@@ -189,7 +189,7 @@ static void paint_log_flume_track_flat(paint_session * session, uint8 rideIndex,
 }
 
 static void paint_log_flume_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = LogFlumeTrackFlatImageIds[direction][0] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 20, 1, height, 0, 6, height + 3);
@@ -215,7 +215,7 @@ static void paint_log_flume_track_station(paint_session * session, uint8 rideInd
         metal_a_supports_paint_setup(session, METAL_SUPPORTS_BOXED, 8, 0, height, session->TrackColours[SCHEME_SUPPORTS]);
     }
 
-    track_paint_util_draw_station_3(session, rideIndex, trackSequence, direction, height + 2, height, mapElement);
+    track_paint_util_draw_station_3(session, rideIndex, trackSequence, direction, height + 2, height, tileElement);
     // Covers shouldn't be offset by +2
 
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
@@ -225,7 +225,7 @@ static void paint_log_flume_track_station(paint_session * session, uint8 rideInd
 }
 
 static void paint_log_flume_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_LOG_FLUME_25_DEG_UP_SW_NE, SPR_LOG_FLUME_25_DEG_UP_FRONT_SW_NE },
@@ -259,7 +259,7 @@ static void paint_log_flume_track_25_deg_up(paint_session * session, uint8 rideI
 }
 
 static void paint_log_flume_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_LOG_FLUME_FLAT_TO_25_DEG_UP_SW_NE, SPR_LOG_FLUME_FLAT_TO_25_DEG_UP_FRONT_SW_NE },
@@ -293,7 +293,7 @@ static void paint_log_flume_track_flat_to_25_deg_up(paint_session * session, uin
 }
 
 static void paint_log_flume_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_LOG_FLUME_25_DEG_UP_TO_FLAT_SW_NE, SPR_LOG_FLUME_25_DEG_UP_TO_FLAT_FRONT_SW_NE },
@@ -327,7 +327,7 @@ static void paint_log_flume_track_25_deg_up_to_flat(paint_session * session, uin
 }
 
 static void paint_log_flume_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_LOG_FLUME_25_DEG_DOWN_SW_NE, SPR_LOG_FLUME_25_DEG_UP_FRONT_NE_SW },
@@ -361,7 +361,7 @@ static void paint_log_flume_track_25_deg_down(paint_session * session, uint8 rid
 }
 
 static void paint_log_flume_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_LOG_FLUME_FLAT_TO_25_DEG_DOWN_SW_NE, SPR_LOG_FLUME_25_DEG_UP_TO_FLAT_FRONT_NE_SW },
@@ -395,7 +395,7 @@ static void paint_log_flume_track_flat_to_25_deg_down(paint_session * session, u
 }
 
 static void paint_log_flume_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_LOG_FLUME_25_DEG_DOWN_TO_FLAT_SW_NE, SPR_LOG_FLUME_FLAT_TO_25_DEG_UP_FRONT_NE_SW },
@@ -429,7 +429,7 @@ static void paint_log_flume_track_25_deg_down_to_flat(paint_session * session, u
 }
 
 static void paint_log_flume_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                              sint32 height, rct_tile_element * mapElement)
+                                              sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4][2] = {
         { { SPR_LOG_FLUME_3_TURN_NE_NW_NE_SEQ_0, SPR_LOG_FLUME_3_TURN_FRONT_NE_NW_NE_SEQ_0 },
@@ -519,7 +519,7 @@ static void paint_log_flume_track_s_bend_left(paint_session * session, uint8 rid
 }
 
 static void paint_log_flume_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4][2] = {
         { { SPR_LOG_FLUME_3_TURN_NE_SE_NE_SEQ_0, SPR_LOG_FLUME_3_TURN_FRONT_NE_SE_NE_SEQ_0 },
@@ -609,7 +609,7 @@ static void paint_log_flume_track_s_bend_right(paint_session * session, uint8 ri
 }
 
 static void paint_log_flume_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_LOG_FLUME_3_TURN_NW_SW_SEQ_0, SPR_LOG_FLUME_3_TURN_NW_SW_SEQ_2, SPR_LOG_FLUME_3_TURN_NW_SW_SEQ_3 },
@@ -676,7 +676,7 @@ static void paint_log_flume_track_left_quarter_turn_3_tiles(paint_session * sess
 }
 
 static void paint_log_flume_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                             uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                             uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][3] = {
         { SPR_LOG_FLUME_3_TURN_NW_NE_SEQ_0, SPR_LOG_FLUME_3_TURN_NW_NE_SEQ_2, SPR_LOG_FLUME_3_TURN_NW_NE_SEQ_3 },
@@ -743,7 +743,7 @@ static void paint_log_flume_track_right_quarter_turn_3_tiles(paint_session * ses
 }
 
 static void paint_log_flume_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                sint32 height, rct_tile_element * mapElement)
+                                                sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId = SPR_STATION_BASE_D | IMAGE_TYPE_REMAP;
     sub_98196C(session, imageId, 0, 0, 32, 32, 1, height, get_current_rotation());
@@ -765,7 +765,7 @@ static void paint_log_flume_track_on_ride_photo(paint_session * session, uint8 r
     imageId = LogFlumeTrackFlatImageIds[direction][1] | session->TrackColours[SCHEME_TRACK];
     sub_98197C_rotated(session, direction, imageId, 0, 0, 32, 1, 21, height, 0, 27, height + 5);
 
-    track_paint_util_onride_photo_paint(session, direction, height + 3, mapElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 3, tileElement);
 
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
     paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0);
@@ -773,7 +773,7 @@ static void paint_log_flume_track_on_ride_photo(paint_session * session, uint8 r
 }
 
 static void paint_log_flume_track_reverser(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                           sint32 height, rct_tile_element * mapElement)
+                                           sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][2] = {
         { SPR_LOG_FLUME_REVERSER_SW_NE, SPR_LOG_FLUME_REVERSER_FRONT_SW_NE },
diff --git a/src/openrct2/ride/water/RiverRapids.cpp b/src/openrct2/ride/water/RiverRapids.cpp
index f4ea16a897..a50f69a644 100644
--- a/src/openrct2/ride/water/RiverRapids.cpp
+++ b/src/openrct2/ride/water/RiverRapids.cpp
@@ -272,7 +272,7 @@ void vehicle_visual_river_rapids(paint_session * session, sint32 x, sint32 image
 
 /** rct2: 0x00757650 */
 static void paint_river_rapids_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -314,12 +314,12 @@ static void paint_river_rapids_track_flat(paint_session * session, uint8 rideInd
 
 /** rct2: 0x007576C0 */
 static void paint_river_rapids_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     Ride * ride = get_ride(rideIndex);
 
-    paint_river_rapids_track_flat(session, rideIndex, trackSequence, direction, height, mapElement);
-    track_paint_util_draw_station_platform(session, ride, direction, height, 12, mapElement);
+    paint_river_rapids_track_flat(session, rideIndex, trackSequence, direction, height, tileElement);
+    track_paint_util_draw_station_platform(session, ride, direction, height, 12, tileElement);
     paint_util_set_general_support_height(session, height + 32, 0x20);
 }
 
@@ -501,35 +501,35 @@ static void paint_river_rapids_track_25_deg_to_flat_b(paint_session * session, u
 
 /** rct2: 0x00757660 */
 static void paint_river_rapids_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     paint_river_rapids_track_25_deg(session, direction, height, river_rapids_track_pieces_25_deg_up);
 }
 
 /** rct2: 0x00757670 */
 static void paint_river_rapids_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     paint_river_rapids_track_25_deg_to_flat_b(session, direction, height, river_rapids_track_pieces_flat_to_25_deg_up);
 }
 
 /** rct2: 0x00757680 */
 static void paint_river_rapids_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     paint_river_rapids_track_25_deg_to_flat_a(session, direction, height, river_rapids_track_pieces_25_deg_up_to_flat);
 }
 
 /** rct2: 0x00757690 */
 static void paint_river_rapids_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     paint_river_rapids_track_25_deg(session, (direction + 2) % 4, height, river_rapids_track_pieces_25_deg_down);
 }
 
 /** rct2: 0x007576A0 */
 static void paint_river_rapids_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     paint_river_rapids_track_25_deg_to_flat_a(session, (direction + 2) % 4, height,
                                               river_rapids_track_pieces_flat_to_25_deg_down);
@@ -537,7 +537,7 @@ static void paint_river_rapids_track_flat_to_25_deg_down(paint_session * session
 
 /** rct2: 0x007576B0 */
 static void paint_river_rapids_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     paint_river_rapids_track_25_deg_to_flat_b(session, (direction + 2) % 4, height,
                                               river_rapids_track_pieces_25_deg_down_to_flat);
@@ -545,7 +545,7 @@ static void paint_river_rapids_track_25_deg_down_to_flat(paint_session * session
 
 /** rct2: 0x007576F0 */
 static void paint_river_rapids_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                              uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                              uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
     switch (direction)
@@ -600,7 +600,7 @@ static void paint_river_rapids_track_left_quarter_turn_1_tile(paint_session * se
 
 /** rct2: 0x00757700 */
 static void paint_river_rapids_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -656,7 +656,7 @@ static void paint_river_rapids_track_right_quarter_turn_1_tile(paint_session * s
 
 /** rct2: 0x00757710 */
 static void paint_river_rapids_track_waterfall(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -718,7 +718,7 @@ static void paint_river_rapids_track_waterfall(paint_session * session, uint8 ri
 
 /** rct2: 0x00757720 */
 static void paint_river_rapids_track_rapids(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -758,16 +758,16 @@ static void paint_river_rapids_track_rapids(paint_session * session, uint8 rideI
 
 /** rct2: 0x00757740 */
 static void paint_river_rapids_track_on_ride_photo(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                   uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                   uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_river_rapids_track_flat(session, rideIndex, trackSequence, direction, height, mapElement);
-    track_paint_util_onride_photo_paint(session, direction, height + 13, mapElement);
+    paint_river_rapids_track_flat(session, rideIndex, trackSequence, direction, height, tileElement);
+    track_paint_util_onride_photo_paint(session, direction, height + 13, tileElement);
     paint_util_set_general_support_height(session, height + 48, 0x20);
 }
 
 /** rct2: 0x */
 static void paint_river_rapids_track_whirlpool(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
diff --git a/src/openrct2/ride/water/SplashBoats.cpp b/src/openrct2/ride/water/SplashBoats.cpp
index 20c76d8fd6..1e90135809 100644
--- a/src/openrct2/ride/water/SplashBoats.cpp
+++ b/src/openrct2/ride/water/SplashBoats.cpp
@@ -481,7 +481,7 @@ static const sprite_bb RiverRaftsRightQuarterTurn5_Side[4][5] = {
 };
 
 static void paint_splash_boats_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoats25DegUpImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoats25DegUpFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -505,7 +505,7 @@ static void paint_splash_boats_track_25_deg_up(paint_session * session, uint8 ri
 }
 
 static void paint_splash_boats_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoats60DegUpImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoats60DegUpFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -529,7 +529,7 @@ static void paint_splash_boats_track_60_deg_up(paint_session * session, uint8 ri
 }
 
 static void paint_splash_boats_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoatsFlatTo25DegUpImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoatsFlatTo25DegUpFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -553,7 +553,7 @@ static void paint_splash_boats_track_flat_to_25_deg_up(paint_session * session,
 }
 
 static void paint_splash_boats_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoats25DegUpToFlatImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoats25DegUpToFlatFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -577,7 +577,7 @@ static void paint_splash_boats_track_25_deg_up_to_flat(paint_session * session,
 }
 
 static void paint_splash_boats_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoats25DegUpTo60DegUpImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoats25DegUpTo60DegUpFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -601,7 +601,7 @@ static void paint_splash_boats_track_25_deg_up_to_60_deg_up(paint_session * sess
 }
 
 static void paint_splash_boats_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                            uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                            uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoats60DegUpTo25DegUpImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoats60DegUpTo25DegUpFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -625,7 +625,7 @@ static void paint_splash_boats_track_60_deg_up_to_25_deg_up(paint_session * sess
 }
 
 static void paint_splash_boats_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoats25DegDownImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoats25DegDownFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -650,13 +650,13 @@ static void paint_splash_boats_track_25_deg_down(paint_session * session, uint8
 }
 
 static void paint_splash_boats_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
-    paint_splash_boats_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    paint_splash_boats_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void paint_splash_boats_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoatsFlatTo25DegDownImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoatsFlatTo25DegDownFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -681,19 +681,19 @@ static void paint_splash_boats_track_flat_to_25_deg_down(paint_session * session
 }
 
 static void paint_splash_boats_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_splash_boats_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    paint_splash_boats_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void paint_splash_boats_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    paint_splash_boats_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    paint_splash_boats_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void paint_splash_boats_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                         uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                         uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId      = SplashBoats25DegDownToFlatImageId[direction] | session->TrackColours[SCHEME_TRACK];
     uint32 frontImageId = SplashBoats25DegDownToFlatFrontImageId[direction] | session->TrackColours[SCHEME_TRACK];
@@ -730,7 +730,7 @@ static void paint_splash_boats_track_25_deg_down_to_flat(paint_session * session
 /** Start of elements originally from River Rafts */
 /** rct2: 0x0089B170 */
 static void paint_splash_boats_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
     uint32 imageId;
 
@@ -772,7 +772,7 @@ static void paint_splash_boats_track_flat(paint_session * session, uint8 rideInd
 
 /** rct2: 0x0089B1A0 */
 static void paint_splash_boats_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
     Ride * ride = get_ride(rideIndex);
 
@@ -797,7 +797,7 @@ static void paint_splash_boats_station(paint_session * session, uint8 rideIndex,
 
     wooden_a_supports_paint_setup(session, (direction & 1), 0, height, session->TrackColours[SCHEME_SUPPORTS], NULL);
 
-    track_paint_util_draw_station_platform(session, ride, direction, height, 7, mapElement);
+    track_paint_util_draw_station_platform(session, ride, direction, height, 7, tileElement);
 
     paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);
 
@@ -807,7 +807,7 @@ static void paint_splash_boats_station(paint_session * session, uint8 rideIndex,
 
 /** rct2: 0x0089B1D0 */
 static void paint_splash_boats_track_left_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_5_tiles_paint_2(session, height, direction, get_current_rotation(), trackSequence,
                                                         session->TrackColours[SCHEME_TRACK], RiverRaftsLeftQuarterTurn5_Top);
@@ -884,7 +884,7 @@ static void paint_splash_boats_track_left_quarter_turn_5_tiles(paint_session * s
 
 /** rct2: 0x0089B1D0 */
 static void paint_splash_boats_track_right_quarter_turn_5_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_right_quarter_turn_5_tiles_paint_2(session, height, direction, get_current_rotation(), trackSequence,
                                                         session->TrackColours[SCHEME_TRACK], RiverRaftsRightQuarterTurn5_Top);
@@ -961,7 +961,7 @@ static void paint_splash_boats_track_right_quarter_turn_5_tiles(paint_session *
 
 /** rct2: 0x0089B180 */
 static void paint_splash_boats_track_s_bend_left(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                                 sint32 height, rct_tile_element * mapElement)
+                                                 sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4][2] = {
         { { SPR_SPLASH_BOATS_S_BEND_TOP_NE_NW_NE_SEQ_0, SPR_SPLASH_BOATS_S_BEND_SIDE_NE_NW_NE_SEQ_0 },
@@ -1050,7 +1050,7 @@ static void paint_splash_boats_track_s_bend_left(paint_session * session, uint8
 
 /** rct2: 0x0089B190 */
 static void paint_splash_boats_track_s_bend_right(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     static const uint32 imageIds[4][4][2] = {
         { { SPR_SPLASH_BOATS_S_BEND_TOP_NE_SE_NE_SEQ_0, SPR_SPLASH_BOATS_S_BEND_SIDE_NE_SE_NE_SEQ_0 },
diff --git a/src/openrct2/ride/water/SubmarineRide.cpp b/src/openrct2/ride/water/SubmarineRide.cpp
index d767091051..8cabfdbb64 100644
--- a/src/openrct2/ride/water/SubmarineRide.cpp
+++ b/src/openrct2/ride/water/SubmarineRide.cpp
@@ -82,7 +82,7 @@ void vehicle_visual_submarine(paint_session * session, sint32 x, sint32 imageDir
 #endif
 
 static void submarine_ride_paint_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16                             position      = session->MapPosition;
     Ride *                               ride          = get_ride(rideIndex);
@@ -96,7 +96,7 @@ static void submarine_ride_paint_track_station(paint_session * session, uint8 ri
         sub_98197C(session, imageId, 0, 0, 20, 32, 3, heightLower, 6, 0, heightLower, get_current_rotation());
 
         paint_util_push_tunnel_right(session, height, TUNNEL_6);
-        track_paint_util_draw_pier(session, ride, entranceStyle, position, direction, height, mapElement,
+        track_paint_util_draw_pier(session, ride, entranceStyle, position, direction, height, tileElement,
                                    get_current_rotation());
     }
     else
@@ -105,7 +105,7 @@ static void submarine_ride_paint_track_station(paint_session * session, uint8 ri
         sub_98197C(session, imageId, 0, 0, 32, 20, 3, heightLower, 0, 6, heightLower, get_current_rotation());
 
         paint_util_push_tunnel_left(session, height, TUNNEL_6);
-        track_paint_util_draw_pier(session, ride, entranceStyle, position, direction, height, mapElement,
+        track_paint_util_draw_pier(session, ride, entranceStyle, position, direction, height, tileElement,
                                    get_current_rotation());
     }
 
@@ -114,7 +114,7 @@ static void submarine_ride_paint_track_station(paint_session * session, uint8 ri
 }
 
 static void submarine_ride_paint_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
     LocationXY16 position    = session->MapPosition;
     sint32   heightLower = height - 16;
@@ -145,7 +145,7 @@ static void submarine_ride_paint_track_flat(paint_session * session, uint8 rideI
 }
 
 static void submarine_ride_paint_track_left_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_left_quarter_turn_3_tiles_paint(
         session, 3, height - 16, direction, trackSequence, session->TrackColours[SCHEME_TRACK],
@@ -175,15 +175,15 @@ static void submarine_ride_paint_track_left_quarter_turn_3_tiles(paint_session *
 
 static const uint8 submarine_ride_right_quarter_turn_3_tiles_to_left_turn_map[] = { 3, 1, 2, 0 };
 static void submarine_ride_paint_track_right_quarter_turn_3_tiles(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = submarine_ride_right_quarter_turn_3_tiles_to_left_turn_map[trackSequence];
     submarine_ride_paint_track_left_quarter_turn_3_tiles(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                         mapElement);
+                                                         tileElement);
 }
 
 static void submarine_ride_paint_track_left_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     track_paint_util_left_quarter_turn_1_tile_paint(session, 1, height - 16, 0, direction, session->TrackColours[SCHEME_TRACK],
                                                     trackSpritesSubmarineRideMiniHelicoptersQuarterTurn1Tile,
@@ -196,10 +196,10 @@ static void submarine_ride_paint_track_left_quarter_turn_1_tile(paint_session *
 }
 
 static void submarine_ride_paint_track_right_quarter_turn_1_tile(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     submarine_ride_paint_track_left_quarter_turn_1_tile(session, rideIndex, trackSequence, (direction + 3) % 4, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 /**
diff --git a/src/openrct2/ride/water/WaterCoaster.cpp b/src/openrct2/ride/water/WaterCoaster.cpp
index f654ec673b..0cf18e0fb6 100644
--- a/src/openrct2/ride/water/WaterCoaster.cpp
+++ b/src/openrct2/ride/water/WaterCoaster.cpp
@@ -20,262 +20,262 @@
 #include "../track_paint.h"
 
 static void water_rc_track_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height,
-                                rct_tile_element * mapElement)
+                                rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                     isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                             isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                             sint32 height, rct_tile_element * mapElement)
+                                             sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                             isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    water_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    water_rc_track_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void water_rc_track_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    water_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    water_rc_track_25_deg_up_to_flat(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void water_rc_track_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                               sint32 height, rct_tile_element * mapElement)
+                                               sint32 height, rct_tile_element * tileElement)
 {
-    water_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);
+    water_rc_track_flat_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);
 }
 
 static void water_rc_track_diag_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                     isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                          isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_flat_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_flat_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_25_deg_up_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_up_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                            isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_flat_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_flat_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                    isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_25_deg_down_to_flat(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                    uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                    uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    bool isChained = track_element_is_lift_hill(mapElement);
-    junior_rc_paint_track_diag_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, mapElement,
+    bool isChained = track_element_is_lift_hill(tileElement);
+    junior_rc_paint_track_diag_25_deg_down_to_flat(session, rideIndex, trackSequence, direction, height, tileElement,
                                                    isChained ? JUNIOR_RC_CHAIN_CHAIN_LIFT : JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                   sint32 height, rct_tile_element * mapElement)
+                                   sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_station(session, rideIndex, trackSequence, direction, height, mapElement, RIDE_TYPE_WATER_COASTER);
+    junior_rc_paint_station(session, rideIndex, trackSequence, direction, height, tileElement, RIDE_TYPE_WATER_COASTER);
 }
 
 static void water_rc_track_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                     sint32 height, rct_tile_element * mapElement)
+                                     sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement, JUNIOR_RC_CHAIN_NONE);
+    junior_rc_paint_track_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement, JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                  JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                       sint32 height, rct_tile_element * mapElement)
+                                       sint32 height, rct_tile_element * tileElement)
 {
-    water_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    water_rc_track_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 static void water_rc_track_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    water_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    water_rc_track_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 static void water_rc_track_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                      uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                      uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    water_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, mapElement);
+    water_rc_track_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, (direction + 2) % 4, height, tileElement);
 }
 
 // 5 tile turns
 
 static void water_rc_track_left_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_left_quarter_turn_5_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                               JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_right_quarter_turn_5_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_right_quarter_turn_5_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                                JUNIOR_RC_CHAIN_NONE);
 }
 
 static const uint8 water_rc_left_quarter_turn_5_tiles_to_right_turn_map[] = { 6, 4, 5, 3, 1, 2, 0 };
 
 static void water_rc_track_left_quarter_turn_5_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     water_rc_track_right_quarter_turn_5_tiles_25_deg_up(session, rideIndex,
                                                         water_rc_left_quarter_turn_5_tiles_to_right_turn_map[trackSequence],
-                                                        (direction + 1) % 4, height, mapElement);
+                                                        (direction + 1) % 4, height, tileElement);
 }
 
 static void water_rc_track_right_quarter_turn_5_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     water_rc_track_left_quarter_turn_5_tiles_25_deg_up(session, rideIndex,
                                                        water_rc_left_quarter_turn_5_tiles_to_right_turn_map[trackSequence],
-                                                       (direction + 3) % 4, height, mapElement);
+                                                       (direction + 3) % 4, height, tileElement);
 }
 
 // 3 tile turns
 
 static void water_rc_track_right_quarter_turn_3_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                                JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_right_quarter_turn_3_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                  uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                  uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     junior_rc_paint_track_right_quarter_turn_3_tiles_25_deg_down(session, rideIndex, trackSequence, direction, height,
-                                                                 mapElement, JUNIOR_RC_CHAIN_NONE);
+                                                                 tileElement, JUNIOR_RC_CHAIN_NONE);
 }
 
 static const uint8 water_rc_left_quarter_turn_3_tiles_to_right_turn_map[] = { 3, 1, 2, 0 };
 
 static void water_rc_track_left_quarter_turn_3_tiles_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                               uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                               uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = water_rc_left_quarter_turn_3_tiles_to_right_turn_map[trackSequence];
     water_rc_track_right_quarter_turn_3_tiles_25_deg_down(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                          mapElement);
+                                                          tileElement);
 }
 
 static void water_rc_track_left_quarter_turn_3_tiles_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                                 uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                                 uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
     trackSequence = water_rc_left_quarter_turn_3_tiles_to_right_turn_map[trackSequence];
     water_rc_track_right_quarter_turn_3_tiles_25_deg_up(session, rideIndex, trackSequence, (direction + 1) % 4, height,
-                                                        mapElement);
+                                                        tileElement);
 }
 
 static void water_rc_track_diag_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                          sint32 height, rct_tile_element * mapElement)
+                                          sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_diag_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_diag_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                          JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_25_deg_up_to_60_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_diag_25_deg_up_to_60_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_60_deg_up_to_25_deg_up(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                       uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                       uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_diag_60_deg_up_to_25_deg_up(session, rideIndex, trackSequence, direction, height, tileElement,
                                                       JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction,
-                                            sint32 height, rct_tile_element * mapElement)
+                                            sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_diag_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_diag_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                            JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_25_deg_down_to_60_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_diag_25_deg_down_to_60_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           JUNIOR_RC_CHAIN_NONE);
 }
 
 static void water_rc_track_diag_60_deg_down_to_25_deg_down(paint_session * session, uint8 rideIndex, uint8 trackSequence,
-                                                           uint8 direction, sint32 height, rct_tile_element * mapElement)
+                                                           uint8 direction, sint32 height, rct_tile_element * tileElement)
 {
-    junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, mapElement,
+    junior_rc_paint_track_diag_60_deg_down_to_25_deg_down(session, rideIndex, trackSequence, direction, height, tileElement,
                                                           JUNIOR_RC_CHAIN_NONE);
 }
 
diff --git a/src/openrct2/windows/Ride.cpp b/src/openrct2/windows/Ride.cpp
index ffe7bbb432..4243b49c3e 100644
--- a/src/openrct2/windows/Ride.cpp
+++ b/src/openrct2/windows/Ride.cpp
@@ -1610,15 +1610,15 @@ rct_window *window_ride_open_station(sint32 rideIndex, sint32 stationIndex)
     return w;
 }
 
-rct_window *window_ride_open_track(rct_tile_element *mapElement)
+rct_window *window_ride_open_track(rct_tile_element *tileElement)
 {
-    sint32 rideIndex = mapElement->properties.track.ride_index;
+    sint32 rideIndex = tileElement->properties.track.ride_index;
     if (
-        (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE) ||
-        (TrackSequenceProperties[mapElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)
+        (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) ||
+        (TrackSequenceProperties[tileElement->properties.track.type][0] & TRACK_SEQUENCE_FLAG_ORIGIN)
     ) {
         // Open ride window in station view
-        return window_ride_open_station(rideIndex, tile_element_get_station(mapElement));
+        return window_ride_open_station(rideIndex, tile_element_get_station(tileElement));
     } else {
         // Open ride window in overview mode.
         return window_ride_main_open(rideIndex);
@@ -4096,27 +4096,27 @@ static sint32 window_ride_has_track_colour(Ride *ride, sint32 trackColour)
 
 static void window_ride_set_track_colour_scheme(rct_window *w, sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     uint8 newColourScheme;
     sint32 interactionType, z, direction;
 
     newColourScheme = (uint8)w->ride_colour;
 
     LocationXY16 mapCoord = { 0 };
-    get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_RIDE, &mapCoord.x, &mapCoord.y, &interactionType, &mapElement, nullptr);
+    get_map_coordinates_from_pos(x, y, VIEWPORT_INTERACTION_MASK_RIDE, &mapCoord.x, &mapCoord.y, &interactionType, &tileElement, nullptr);
     x = mapCoord.x;
     y = mapCoord.y;
 
     if (interactionType != VIEWPORT_INTERACTION_ITEM_RIDE)
         return;
-    if (mapElement->properties.track.ride_index != w->number)
+    if (tileElement->properties.track.ride_index != w->number)
         return;
-    if (track_element_get_colour_scheme(mapElement) == newColourScheme)
+    if (track_element_get_colour_scheme(tileElement) == newColourScheme)
         return;
 
-    z = mapElement->base_height * 8;
-    direction = tile_element_get_direction(mapElement);
-    sub_6C683D(&x, &y, &z, direction, mapElement->properties.track.type, newColourScheme, nullptr, 4);
+    z = tileElement->base_height * 8;
+    direction = tile_element_get_direction(tileElement);
+    sub_6C683D(&x, &y, &z, direction, tileElement->properties.track.type, newColourScheme, nullptr, 4);
 }
 
 /**
@@ -5154,7 +5154,7 @@ static void window_ride_measurements_update(rct_window *w)
  */
 static void window_ride_measurements_tooldown(rct_window *w, rct_widgetindex widgetIndex, sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     sint16 mapX, mapY;
     sint32 interactionType;
 
@@ -5162,14 +5162,14 @@ static void window_ride_measurements_tooldown(rct_window *w, rct_widgetindex wid
     _lastSceneryY = y;
     _collectTrackDesignScenery = true; // Default to true in case user does not select anything valid
 
-    get_map_coordinates_from_pos(x, y, 0xFCCF, &mapX, &mapY, &interactionType, &mapElement, nullptr);
+    get_map_coordinates_from_pos(x, y, 0xFCCF, &mapX, &mapY, &interactionType, &tileElement, nullptr);
     switch (interactionType) {
     case VIEWPORT_INTERACTION_ITEM_SCENERY:
     case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
     case VIEWPORT_INTERACTION_ITEM_WALL:
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH:
-        _collectTrackDesignScenery = !track_design_save_contains_tile_element(mapElement);
-        track_design_save_select_tile_element(interactionType, mapX, mapY, mapElement, _collectTrackDesignScenery);
+        _collectTrackDesignScenery = !track_design_save_contains_tile_element(tileElement);
+        track_design_save_select_tile_element(interactionType, mapX, mapY, tileElement, _collectTrackDesignScenery);
         break;
     }
 }
@@ -5181,17 +5181,17 @@ static void window_ride_measurements_tooldrag(rct_window *w, rct_widgetindex wid
     _lastSceneryX = x;
     _lastSceneryY = y;
 
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     sint16 mapX, mapY;
     sint32 interactionType;
 
-    get_map_coordinates_from_pos(x, y, 0xFCCF, &mapX, &mapY, &interactionType, &mapElement, nullptr);
+    get_map_coordinates_from_pos(x, y, 0xFCCF, &mapX, &mapY, &interactionType, &tileElement, nullptr);
     switch (interactionType) {
     case VIEWPORT_INTERACTION_ITEM_SCENERY:
     case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
     case VIEWPORT_INTERACTION_ITEM_WALL:
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH:
-        track_design_save_select_tile_element(interactionType, mapX, mapY, mapElement, _collectTrackDesignScenery);
+        track_design_save_select_tile_element(interactionType, mapX, mapY, tileElement, _collectTrackDesignScenery);
         break;
     }
 }
diff --git a/src/openrct2/windows/RideConstruction.cpp b/src/openrct2/windows/RideConstruction.cpp
index 5223819ccc..873b2401e0 100644
--- a/src/openrct2/windows/RideConstruction.cpp
+++ b/src/openrct2/windows/RideConstruction.cpp
@@ -1766,7 +1766,7 @@ static void window_ride_construction_construct(rct_window *w)
 static void window_ride_construction_mouseup_demolish(rct_window* w)
 {
     sint32 x, y, z, direction, type;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_xy_element inputElement, outputElement;
     track_begin_end trackBeginEnd;
     //bool gotoStartPlacementMode;
@@ -1796,7 +1796,7 @@ static void window_ride_construction_mouseup_demolish(rct_window* w)
     z = _currentTrackBeginZ;
     direction = _currentTrackPieceDirection;
     type = _currentTrackPieceType;
-    if (sub_6C683D(&x, &y, &z, direction & 3, type, 0, &mapElement, 0)) {
+    if (sub_6C683D(&x, &y, &z, direction & 3, type, 0, &tileElement, 0)) {
         window_ride_construction_update_active_elements();
         return;
     }
@@ -1804,8 +1804,8 @@ static void window_ride_construction_mouseup_demolish(rct_window* w)
     // Get the previous track element to go to after the selected track element is deleted
     inputElement.x = x;
     inputElement.y = y;
-    inputElement.element = mapElement;
-    if (track_block_get_previous(x, y, mapElement, &trackBeginEnd)) {
+    inputElement.element = tileElement;
+    if (track_block_get_previous(x, y, tileElement, &trackBeginEnd)) {
         x = trackBeginEnd.begin_x;
         y = trackBeginEnd.begin_y;
         z = trackBeginEnd.begin_z;
@@ -1826,13 +1826,13 @@ static void window_ride_construction_mouseup_demolish(rct_window* w)
         direction = _currentTrackPieceDirection;
         type = _currentTrackPieceType;
 
-        if (sub_6C683D(&x, &y, &z, direction, type, 0, &mapElement, 0)) {
+        if (sub_6C683D(&x, &y, &z, direction, type, 0, &tileElement, 0)) {
             window_ride_construction_update_active_elements();
             return;
         }
 
-        const rct_preview_track *trackBlock = get_track_def_from_ride_index(_currentRideIndex, mapElement->properties.track.type);
-        z = (mapElement->base_height * 8) - trackBlock->z;
+        const rct_preview_track *trackBlock = get_track_def_from_ride_index(_currentRideIndex, tileElement->properties.track.type);
+        z = (tileElement->base_height * 8) - trackBlock->z;
         gGotoStartPlacementMode = true;
     }
 
@@ -2052,14 +2052,14 @@ static bool ride_get_place_position_from_screen_position(sint32 screenX, sint32
 {
     sint16 mapX, mapY, mapZ;
     sint32 interactionType, direction;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_viewport *viewport;
 
     if (!_trackPlaceCtrlState) {
         if (gInputPlaceObjectModifier & PLACE_OBJECT_MODIFIER_COPY_Z) {
-            get_map_coordinates_from_pos(screenX, screenY, 0xFCCA, &mapX, &mapY, &interactionType, &mapElement, &viewport);
+            get_map_coordinates_from_pos(screenX, screenY, 0xFCCA, &mapX, &mapY, &interactionType, &tileElement, &viewport);
             if (interactionType != 0) {
-                _trackPlaceCtrlZ = mapElement->base_height * 8;
+                _trackPlaceCtrlZ = tileElement->base_height * 8;
                 _trackPlaceCtrlState = true;
             }
         }
@@ -2087,14 +2087,14 @@ static bool ride_get_place_position_from_screen_position(sint32 screenX, sint32
     }
 
     if (!_trackPlaceCtrlState) {
-        sub_68A15E(screenX, screenY, &mapX, &mapY, &direction, &mapElement);
+        sub_68A15E(screenX, screenY, &mapX, &mapY, &direction, &tileElement);
         if (mapX == LOCATION_NULL)
             return false;
 
         _trackPlaceZ = 0;
         if (_trackPlaceShiftState) {
-            mapElement = map_get_surface_element_at(mapX >> 5, mapY >> 5);
-            mapZ = floor2(mapElement->base_height * 8, 16);
+            tileElement = map_get_surface_element_at(mapX >> 5, mapY >> 5);
+            mapZ = floor2(tileElement->base_height * 8, 16);
             mapZ += _trackPlaceShiftZ;
             mapZ = Math::Max<sint16>(mapZ, 16);
             _trackPlaceZ = mapZ;
@@ -2296,9 +2296,9 @@ static void window_ride_construction_draw_track_piece(
     sub_6CBCE2(dpi, rideIndex, trackType, trackDirection, d, 4096, 4096, 1024);
 }
 
-static rct_tile_element _tempTrackMapElement;
-static rct_tile_element _tempSideTrackMapElement = { 0x80, 0x8F, 128, 128, 0, 0, 0, 0 };
-static rct_tile_element *_backupMapElementArrays[5];
+static rct_tile_element _tempTrackTileElement;
+static rct_tile_element _tempSideTrackTileElement = { 0x80, 0x8F, 128, 128, 0, 0, 0, 0 };
+static rct_tile_element *_backupTileElementArrays[5];
 
 /**
  *
@@ -2384,40 +2384,40 @@ static void sub_6CBCE2(
         sint32 tileY = y >> 5;
 
         // Replace map elements with temporary ones containing track
-        _backupMapElementArrays[0] = map_get_first_element_at(tileX + 0, tileY + 0);
-        _backupMapElementArrays[1] = map_get_first_element_at(tileX + 1, tileY + 0);
-        _backupMapElementArrays[2] = map_get_first_element_at(tileX - 1, tileY + 0);
-        _backupMapElementArrays[3] = map_get_first_element_at(tileX + 0, tileY + 1);
-        _backupMapElementArrays[4] = map_get_first_element_at(tileX + 0, tileY - 1);
-        map_set_tile_elements(tileX + 0, tileY + 0, &_tempTrackMapElement);
-        map_set_tile_elements(tileX + 1, tileY + 0, &_tempSideTrackMapElement);
-        map_set_tile_elements(tileX - 1, tileY + 0, &_tempSideTrackMapElement);
-        map_set_tile_elements(tileX + 0, tileY + 1, &_tempSideTrackMapElement);
-        map_set_tile_elements(tileX + 0, tileY - 1, &_tempSideTrackMapElement);
+        _backupTileElementArrays[0] = map_get_first_element_at(tileX + 0, tileY + 0);
+        _backupTileElementArrays[1] = map_get_first_element_at(tileX + 1, tileY + 0);
+        _backupTileElementArrays[2] = map_get_first_element_at(tileX - 1, tileY + 0);
+        _backupTileElementArrays[3] = map_get_first_element_at(tileX + 0, tileY + 1);
+        _backupTileElementArrays[4] = map_get_first_element_at(tileX + 0, tileY - 1);
+        map_set_tile_elements(tileX + 0, tileY + 0, &_tempTrackTileElement);
+        map_set_tile_elements(tileX + 1, tileY + 0, &_tempSideTrackTileElement);
+        map_set_tile_elements(tileX - 1, tileY + 0, &_tempSideTrackTileElement);
+        map_set_tile_elements(tileX + 0, tileY + 1, &_tempSideTrackTileElement);
+        map_set_tile_elements(tileX + 0, tileY - 1, &_tempSideTrackTileElement);
 
         // Set the temporary track element
-        _tempTrackMapElement.type = trackDirection | TILE_ELEMENT_TYPE_TRACK | ((edx & 0x10000) ? 0x80 : 0);
-        _tempTrackMapElement.flags = (bl & 0x0F) | TILE_ELEMENT_FLAG_LAST_TILE;
-        _tempTrackMapElement.base_height = baseZ;
-        _tempTrackMapElement.clearance_height = clearanceZ;
-        _tempTrackMapElement.properties.track.type = trackType;
-        tile_element_set_track_sequence(&_tempTrackMapElement, trackBlock->index);
-        _tempTrackMapElement.properties.track.colour = 0;
-        _tempTrackMapElement.properties.track.ride_index = rideIndex;
+        _tempTrackTileElement.type = trackDirection | TILE_ELEMENT_TYPE_TRACK | ((edx & 0x10000) ? 0x80 : 0);
+        _tempTrackTileElement.flags = (bl & 0x0F) | TILE_ELEMENT_FLAG_LAST_TILE;
+        _tempTrackTileElement.base_height = baseZ;
+        _tempTrackTileElement.clearance_height = clearanceZ;
+        _tempTrackTileElement.properties.track.type = trackType;
+        tile_element_set_track_sequence(&_tempTrackTileElement, trackBlock->index);
+        _tempTrackTileElement.properties.track.colour = 0;
+        _tempTrackTileElement.properties.track.ride_index = rideIndex;
         if (edx & 0x20000)
         {
-            track_element_set_inverted(&_tempTrackMapElement, true);
+            track_element_set_inverted(&_tempTrackTileElement, true);
         }
 
         // Draw this map tile
         sub_68B2B7(session, x, y);
 
         // Restore map elements
-        map_set_tile_elements(tileX + 0, tileY + 0, _backupMapElementArrays[0]);
-        map_set_tile_elements(tileX + 1, tileY + 0, _backupMapElementArrays[1]);
-        map_set_tile_elements(tileX - 1, tileY + 0, _backupMapElementArrays[2]);
-        map_set_tile_elements(tileX + 0, tileY + 1, _backupMapElementArrays[3]);
-        map_set_tile_elements(tileX + 0, tileY - 1, _backupMapElementArrays[4]);
+        map_set_tile_elements(tileX + 0, tileY + 0, _backupTileElementArrays[0]);
+        map_set_tile_elements(tileX + 1, tileY + 0, _backupTileElementArrays[1]);
+        map_set_tile_elements(tileX - 1, tileY + 0, _backupTileElementArrays[2]);
+        map_set_tile_elements(tileX + 0, tileY + 1, _backupTileElementArrays[3]);
+        map_set_tile_elements(tileX + 0, tileY - 1, _backupTileElementArrays[4]);
 
         trackBlock++;
     }
@@ -2441,7 +2441,7 @@ static void sub_6CBCE2(
 void window_ride_construction_update_active_elements()
 {
     rct_window *w;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     window_ride_construction_update_enabled_track_pieces();
     w = window_find_by_class(WC_RIDE_CONSTRUCTION);
@@ -2455,11 +2455,11 @@ void window_ride_construction_update_active_elements()
         sint32 x = _currentTrackBeginX;
         sint32 y = _currentTrackBeginY;
         sint32 z = _currentTrackBeginZ;
-        if (!sub_6C683D(&x, &y, &z, _currentTrackPieceDirection & 3, _currentTrackPieceType, 0, &mapElement, 0)) {
-            _selectedTrackType = mapElement->properties.track.type;
-            if (track_element_has_speed_setting(mapElement->properties.track.type))
-                _currentBrakeSpeed2 = tile_element_get_brake_booster_speed(mapElement);
-            _currentSeatRotationAngle = track_element_get_seat_rotation(mapElement);
+        if (!sub_6C683D(&x, &y, &z, _currentTrackPieceDirection & 3, _currentTrackPieceType, 0, &tileElement, 0)) {
+            _selectedTrackType = tileElement->properties.track.type;
+            if (track_element_has_speed_setting(tileElement->properties.track.type))
+                _currentBrakeSpeed2 = tile_element_get_brake_booster_speed(tileElement);
+            _currentSeatRotationAngle = track_element_get_seat_rotation(tileElement);
         }
     }
 
@@ -3619,18 +3619,18 @@ static void loc_6C7502(sint32 al)
  */
 static void ride_construction_set_brakes_speed(sint32 brakesSpeed)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     sint32 x, y, z;
 
     x = _currentTrackBeginX;
     y = _currentTrackBeginY;
     z = _currentTrackBeginZ;
-    if (!sub_6C683D(&x, &y, &z, _currentTrackPieceDirection & 3, _currentTrackPieceType, 0, &mapElement, 0)) {
+    if (!sub_6C683D(&x, &y, &z, _currentTrackPieceDirection & 3, _currentTrackPieceType, 0, &tileElement, 0)) {
         game_do_command(
             _currentTrackBeginX,
             GAME_COMMAND_FLAG_APPLY | ((brakesSpeed) << 8),
             _currentTrackBeginY,
-            mapElement->properties.track.type,
+            tileElement->properties.track.type,
             GAME_COMMAND_SET_BRAKES_SPEED,
             _currentTrackBeginZ,
             0
diff --git a/src/openrct2/windows/TileInspector.cpp b/src/openrct2/windows/TileInspector.cpp
index 9418a32bd9..79e1e6377b 100644
--- a/src/openrct2/windows/TileInspector.cpp
+++ b/src/openrct2/windows/TileInspector.cpp
@@ -586,8 +586,8 @@ static void window_tile_inspector_select_element_from_list(rct_window *w, sint32
         w->selected_list_item = index;
 
         // Get type of selected map element to select the correct page
-        rct_tile_element *const mapElement = window_tile_inspector_get_selected_element(w);
-        page = (Math::Min<uint32>(tile_element_get_type(mapElement), TILE_ELEMENT_TYPE_CORRUPT) >> 2) + 1;
+        rct_tile_element *const tileElement = window_tile_inspector_get_selected_element(w);
+        page = (Math::Min<uint32>(tile_element_get_type(tileElement), TILE_ELEMENT_TYPE_CORRUPT) >> 2) + 1;
     }
 
     window_tile_inspector_set_page(w, (tile_inspector_page)page);
@@ -967,7 +967,7 @@ static void window_tile_inspector_mouseup(rct_window *w, rct_widgetindex widgetI
     }
 
     // Get the selected map element
-    rct_tile_element *const mapElement = window_tile_inspector_get_selected_element(w);
+    rct_tile_element *const tileElement = window_tile_inspector_get_selected_element(w);
 
     // Page widgets
     switch (w->page) {
@@ -1006,7 +1006,7 @@ static void window_tile_inspector_mouseup(rct_window *w, rct_widgetindex widgetI
             window_tile_inspector_base_height_offset(w->selected_list_item, -1);
             break;
         case WIDX_PATH_CHECK_SLOPED:
-            window_tile_inspector_path_set_sloped(w->selected_list_item, !footpath_element_is_sloped(mapElement));
+            window_tile_inspector_path_set_sloped(w->selected_list_item, !footpath_element_is_sloped(tileElement));
             break;
         case WIDX_PATH_CHECK_EDGE_E:
         case WIDX_PATH_CHECK_EDGE_S:
@@ -1060,7 +1060,7 @@ static void window_tile_inspector_mouseup(rct_window *w, rct_widgetindex widgetI
         case WIDX_TRACK_CHECK_CHAIN_LIFT:
         {
             bool entireTrackBlock = widget_is_pressed(w, WIDX_TRACK_CHECK_APPLY_TO_ALL);
-            bool newLift = !track_element_is_lift_hill(mapElement);
+            bool newLift = !track_element_is_lift_hill(tileElement);
             window_tile_inspector_track_block_set_lift(w->selected_list_item, entireTrackBlock, newLift);
             break;
         }
@@ -1198,8 +1198,8 @@ static void window_tile_inspector_mousedown(rct_window *w, rct_widgetindex widge
             );
 
             // Set current value as checked
-            rct_tile_element *const mapElement = window_tile_inspector_get_selected_element(w);
-            dropdown_set_checked((mapElement->type & 0xC0) >> 6, true);
+            rct_tile_element *const tileElement = window_tile_inspector_get_selected_element(w);
+            dropdown_set_checked((tileElement->type & 0xC0) >> 6, true);
             break;
         }
         break;
@@ -1225,11 +1225,11 @@ static void window_tile_inspector_dropdown(rct_window *w, rct_widgetindex widget
     }
 
     // Get selected element
-    rct_tile_element *const mapElement = window_tile_inspector_get_selected_element(w);
+    rct_tile_element *const tileElement = window_tile_inspector_get_selected_element(w);
 
     switch (w->page) {
     case TILE_INSPECTOR_PAGE_WALL:
-        openrct2_assert(tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_WALL, "Element is not a wall");
+        openrct2_assert(tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL, "Element is not a wall");
 
         switch (widgetIndex) {
         case WIDX_WALL_DROPDOWN_SLOPE_BUTTON:
@@ -1352,8 +1352,8 @@ void window_tile_inspector_auto_set_buttons(rct_window *w)
     // Page widgets
     switch (w->page) {
     case TILE_INSPECTOR_PAGE_WALL: {
-        const rct_tile_element *const mapElement = window_tile_inspector_get_selected_element(w);
-        const uint8 wallType = mapElement->properties.wall.type;
+        const rct_tile_element *const tileElement = window_tile_inspector_get_selected_element(w);
+        const uint8 wallType = tileElement->properties.wall.type;
         const rct_wall_scenery_entry wallEntry = get_wall_entry(wallType)->wall;
         const bool canBeSloped = !(wallEntry.flags & WALL_SCENERY_CANT_BUILD_ON_SLOPE);
         // Wall slope dropdown
@@ -1412,7 +1412,7 @@ static void window_tile_inspector_invalidate(rct_window *w)
     // Using a switch, because I don't think giving each page their own callbacks is
     // needed here, as only the mouseup and invalidate functions are different.
     const sint32 propertiesAnchor = w->widgets[WIDX_GROUPBOX_PROPERTIES].top;
-    rct_tile_element *const mapElement = window_tile_inspector_get_selected_element(w);
+    rct_tile_element *const tileElement = window_tile_inspector_get_selected_element(w);
 
     switch (w->page) {
     case TILE_INSPECTOR_PAGE_SURFACE:
@@ -1436,11 +1436,11 @@ static void window_tile_inspector_invalidate(rct_window *w)
         w->widgets[WIDX_SURFACE_CHECK_CORNER_W].bottom = w->widgets[WIDX_SURFACE_CHECK_CORNER_W].top + 13;
         w->widgets[WIDX_SURFACE_CHECK_DIAGONAL].top = GBBT(propertiesAnchor, 3) + 7 * 1;
         w->widgets[WIDX_SURFACE_CHECK_DIAGONAL].bottom = w->widgets[WIDX_SURFACE_CHECK_DIAGONAL].top + 13;
-        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_CORNER_N, mapElement->properties.surface.slope & (1 << ((2 - get_current_rotation()) & 3)));
-        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_CORNER_E, mapElement->properties.surface.slope & (1 << ((3 - get_current_rotation()) & 3)));
-        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_CORNER_S, mapElement->properties.surface.slope & (1 << ((0 - get_current_rotation()) & 3)));
-        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_CORNER_W, mapElement->properties.surface.slope & (1 << ((1 - get_current_rotation()) & 3)));
-        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_DIAGONAL, mapElement->properties.surface.slope & 0x10);
+        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_CORNER_N, tileElement->properties.surface.slope & (1 << ((2 - get_current_rotation()) & 3)));
+        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_CORNER_E, tileElement->properties.surface.slope & (1 << ((3 - get_current_rotation()) & 3)));
+        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_CORNER_S, tileElement->properties.surface.slope & (1 << ((0 - get_current_rotation()) & 3)));
+        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_CORNER_W, tileElement->properties.surface.slope & (1 << ((1 - get_current_rotation()) & 3)));
+        widget_set_checkbox_value(w, WIDX_SURFACE_CHECK_DIAGONAL, tileElement->properties.surface.slope & 0x10);
         break;
     case TILE_INSPECTOR_PAGE_PATH:
         w->widgets[WIDX_PATH_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
@@ -1467,15 +1467,15 @@ static void window_tile_inspector_invalidate(rct_window *w)
         w->widgets[WIDX_PATH_CHECK_EDGE_W].bottom = w->widgets[WIDX_PATH_CHECK_EDGE_W].top + 13;
         w->widgets[WIDX_PATH_CHECK_EDGE_NW].top = GBBT(propertiesAnchor, 2) + 7 * 1;
         w->widgets[WIDX_PATH_CHECK_EDGE_NW].bottom = w->widgets[WIDX_PATH_CHECK_EDGE_NW].top + 13;
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_SLOPED, footpath_element_is_sloped(mapElement));
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_NE, mapElement->properties.path.edges & (1 << ((0 - get_current_rotation()) & 3)));
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_SE, mapElement->properties.path.edges & (1 << ((1 - get_current_rotation()) & 3)));
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_SW, mapElement->properties.path.edges & (1 << ((2 - get_current_rotation()) & 3)));
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_NW, mapElement->properties.path.edges & (1 << ((3 - get_current_rotation()) & 3)));
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_E, mapElement->properties.path.edges & (1 << (4 + ((0 - get_current_rotation()) & 3))));
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_S, mapElement->properties.path.edges & (1 << (4 + ((1 - get_current_rotation()) & 3))));
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_W, mapElement->properties.path.edges & (1 << (4 + ((2 - get_current_rotation()) & 3))));
-        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_N, mapElement->properties.path.edges & (1 << (4 + ((3 - get_current_rotation()) & 3))));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_SLOPED, footpath_element_is_sloped(tileElement));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_NE, tileElement->properties.path.edges & (1 << ((0 - get_current_rotation()) & 3)));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_SE, tileElement->properties.path.edges & (1 << ((1 - get_current_rotation()) & 3)));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_SW, tileElement->properties.path.edges & (1 << ((2 - get_current_rotation()) & 3)));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_NW, tileElement->properties.path.edges & (1 << ((3 - get_current_rotation()) & 3)));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_E, tileElement->properties.path.edges & (1 << (4 + ((0 - get_current_rotation()) & 3))));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_S, tileElement->properties.path.edges & (1 << (4 + ((1 - get_current_rotation()) & 3))));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_W, tileElement->properties.path.edges & (1 << (4 + ((2 - get_current_rotation()) & 3))));
+        widget_set_checkbox_value(w, WIDX_PATH_CHECK_EDGE_N, tileElement->properties.path.edges & (1 << (4 + ((3 - get_current_rotation()) & 3))));
         break;
     case TILE_INSPECTOR_PAGE_TRACK:
         w->widgets[WIDX_TRACK_CHECK_APPLY_TO_ALL].top = GBBT(propertiesAnchor, 0);
@@ -1489,7 +1489,7 @@ static void window_tile_inspector_invalidate(rct_window *w)
         w->widgets[WIDX_TRACK_CHECK_CHAIN_LIFT].top = GBBT(propertiesAnchor, 2);
         w->widgets[WIDX_TRACK_CHECK_CHAIN_LIFT].bottom = GBBB(propertiesAnchor, 2);
         widget_set_checkbox_value(w, WIDX_TRACK_CHECK_APPLY_TO_ALL, windowTileInspectorApplyToAll);
-        widget_set_checkbox_value(w, WIDX_TRACK_CHECK_CHAIN_LIFT, track_element_is_lift_hill(mapElement));
+        widget_set_checkbox_value(w, WIDX_TRACK_CHECK_CHAIN_LIFT, track_element_is_lift_hill(tileElement));
         break;
     case TILE_INSPECTOR_PAGE_SCENERY: {
         // Raise / Lower
@@ -1510,10 +1510,10 @@ static void window_tile_inspector_invalidate(rct_window *w)
         w->widgets[WIDX_SCENERY_CHECK_QUARTER_W].top = GBBT(propertiesAnchor, 1) - 5 + 7 * 1;
         w->widgets[WIDX_SCENERY_CHECK_QUARTER_W].bottom = w->widgets[WIDX_SCENERY_CHECK_QUARTER_W].top + 13;
         // This gets the relative rotation, by subtracting the camera's rotation, and wrapping it between 0-3 inclusive
-        bool N = (mapElement->type & TILE_ELEMENT_QUADRANT_MASK) == ((0 - get_current_rotation()) & 3) << 6;
-        bool E = (mapElement->type & TILE_ELEMENT_QUADRANT_MASK) == ((1 - get_current_rotation()) & 3) << 6;
-        bool S = (mapElement->type & TILE_ELEMENT_QUADRANT_MASK) == ((2 - get_current_rotation()) & 3) << 6;
-        bool W = (mapElement->type & TILE_ELEMENT_QUADRANT_MASK) == ((3 - get_current_rotation()) & 3) << 6;
+        bool N = (tileElement->type & TILE_ELEMENT_QUADRANT_MASK) == ((0 - get_current_rotation()) & 3) << 6;
+        bool E = (tileElement->type & TILE_ELEMENT_QUADRANT_MASK) == ((1 - get_current_rotation()) & 3) << 6;
+        bool S = (tileElement->type & TILE_ELEMENT_QUADRANT_MASK) == ((2 - get_current_rotation()) & 3) << 6;
+        bool W = (tileElement->type & TILE_ELEMENT_QUADRANT_MASK) == ((3 - get_current_rotation()) & 3) << 6;
         widget_set_checkbox_value(w, WIDX_SCENERY_CHECK_QUARTER_N, N);
         widget_set_checkbox_value(w, WIDX_SCENERY_CHECK_QUARTER_E, E);
         widget_set_checkbox_value(w, WIDX_SCENERY_CHECK_QUARTER_S, S);
@@ -1528,10 +1528,10 @@ static void window_tile_inspector_invalidate(rct_window *w)
         w->widgets[WIDX_SCENERY_CHECK_COLLISION_S].bottom = w->widgets[WIDX_SCENERY_CHECK_COLLISION_S].top + 13;
         w->widgets[WIDX_SCENERY_CHECK_COLLISION_W].top = GBBT(propertiesAnchor, 2) + 5 + 7 * 1;
         w->widgets[WIDX_SCENERY_CHECK_COLLISION_W].bottom = w->widgets[WIDX_SCENERY_CHECK_COLLISION_W].top + 13;
-        N = (mapElement->flags & (1 << ((2 - get_current_rotation()) & 3))) != 0;
-        E = (mapElement->flags & (1 << ((3 - get_current_rotation()) & 3))) != 0;
-        S = (mapElement->flags & (1 << ((0 - get_current_rotation()) & 3))) != 0;
-        W = (mapElement->flags & (1 << ((1 - get_current_rotation()) & 3))) != 0;
+        N = (tileElement->flags & (1 << ((2 - get_current_rotation()) & 3))) != 0;
+        E = (tileElement->flags & (1 << ((3 - get_current_rotation()) & 3))) != 0;
+        S = (tileElement->flags & (1 << ((0 - get_current_rotation()) & 3))) != 0;
+        W = (tileElement->flags & (1 << ((1 - get_current_rotation()) & 3))) != 0;
         widget_set_checkbox_value(w, WIDX_SCENERY_CHECK_COLLISION_N, N);
         widget_set_checkbox_value(w, WIDX_SCENERY_CHECK_COLLISION_E, E);
         widget_set_checkbox_value(w, WIDX_SCENERY_CHECK_COLLISION_S, S);
@@ -1555,7 +1555,7 @@ static void window_tile_inspector_invalidate(rct_window *w)
         w->widgets[WIDX_WALL_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
         w->widgets[WIDX_WALL_DROPDOWN_SLOPE].top = GBBT(propertiesAnchor, 1) + 3;
         w->widgets[WIDX_WALL_DROPDOWN_SLOPE].bottom = GBBB(propertiesAnchor, 1) - 3;
-        w->widgets[WIDX_WALL_DROPDOWN_SLOPE].text = WallSlopeStringIds[(mapElement->type & 0xC0) >> 6];
+        w->widgets[WIDX_WALL_DROPDOWN_SLOPE].text = WallSlopeStringIds[(tileElement->type & 0xC0) >> 6];
         w->widgets[WIDX_WALL_DROPDOWN_SLOPE_BUTTON].top = GBBT(propertiesAnchor, 1) + 4;
         w->widgets[WIDX_WALL_DROPDOWN_SLOPE_BUTTON].bottom = GBBB(propertiesAnchor, 1) - 4;
         break;
@@ -1574,10 +1574,10 @@ static void window_tile_inspector_invalidate(rct_window *w)
         w->widgets[WIDX_BANNER_SPINNER_HEIGHT_INCREASE].bottom = GBBT(propertiesAnchor, 0) + 8;
         w->widgets[WIDX_BANNER_SPINNER_HEIGHT_DECREASE].top = GBBB(propertiesAnchor, 0) - 8;
         w->widgets[WIDX_BANNER_SPINNER_HEIGHT_DECREASE].bottom = GBBB(propertiesAnchor, 0) - 4;
-        widget_set_checkbox_value(w, WIDX_BANNER_CHECK_BLOCK_NE, !(mapElement->properties.banner.flags & (1 << ((0 - get_current_rotation()) & 3))));
-        widget_set_checkbox_value(w, WIDX_BANNER_CHECK_BLOCK_SE, !(mapElement->properties.banner.flags & (1 << ((1 - get_current_rotation()) & 3))));
-        widget_set_checkbox_value(w, WIDX_BANNER_CHECK_BLOCK_SW, !(mapElement->properties.banner.flags & (1 << ((2 - get_current_rotation()) & 3))));
-        widget_set_checkbox_value(w, WIDX_BANNER_CHECK_BLOCK_NW, !(mapElement->properties.banner.flags & (1 << ((3 - get_current_rotation()) & 3))));
+        widget_set_checkbox_value(w, WIDX_BANNER_CHECK_BLOCK_NE, !(tileElement->properties.banner.flags & (1 << ((0 - get_current_rotation()) & 3))));
+        widget_set_checkbox_value(w, WIDX_BANNER_CHECK_BLOCK_SE, !(tileElement->properties.banner.flags & (1 << ((1 - get_current_rotation()) & 3))));
+        widget_set_checkbox_value(w, WIDX_BANNER_CHECK_BLOCK_SW, !(tileElement->properties.banner.flags & (1 << ((2 - get_current_rotation()) & 3))));
+        widget_set_checkbox_value(w, WIDX_BANNER_CHECK_BLOCK_NW, !(tileElement->properties.banner.flags & (1 << ((3 - get_current_rotation()) & 3))));
         break;
     case TILE_INSPECTOR_PAGE_CORRUPT:
         w->widgets[WIDX_CORRUPT_SPINNER_HEIGHT].top = GBBT(propertiesAnchor, 0) + 3;
@@ -1638,32 +1638,32 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
         sint32 y = w->y + w->widgets[WIDX_GROUPBOX_DETAILS].top + 14;
 
         // Get map element
-        rct_tile_element *const mapElement = window_tile_inspector_get_selected_element(w);
+        rct_tile_element *const tileElement = window_tile_inspector_get_selected_element(w);
 
         switch (w->page) {
         case TILE_INSPECTOR_PAGE_SURFACE: {
             // Details
             // Terrain texture name
-            rct_string_id terrainNameId = TerrainTypeStringIds[tile_element_get_terrain(mapElement)];
+            rct_string_id terrainNameId = TerrainTypeStringIds[tile_element_get_terrain(tileElement)];
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SURFACE_TERAIN, &terrainNameId, COLOUR_DARK_GREEN, x, y);
 
             // Edge texture name
-            sint32 idx = tile_element_get_terrain_edge(mapElement);
+            sint32 idx = tile_element_get_terrain_edge(tileElement);
             openrct2_assert((uint32)idx < Util::CountOf(TerrainEdgeTypeStringIds), "Tried accessing invalid entry %d in terrainEdgeTypeStringIds", idx);
-            rct_string_id terrainEdgeNameId = TerrainEdgeTypeStringIds[tile_element_get_terrain_edge(mapElement)];
+            rct_string_id terrainEdgeNameId = TerrainEdgeTypeStringIds[tile_element_get_terrain_edge(tileElement)];
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SURFACE_EDGE, &terrainEdgeNameId, COLOUR_DARK_GREEN, x, y + 11);
 
             // Land ownership
             rct_string_id landOwnership;
-            if (mapElement->properties.surface.ownership & OWNERSHIP_OWNED) landOwnership = STR_LAND_OWNED;
-            else if (mapElement->properties.surface.ownership & OWNERSHIP_AVAILABLE) landOwnership = STR_LAND_SALE;
-            else if (mapElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) landOwnership = STR_CONSTRUCTION_RIGHTS_OWNED;
-            else if (mapElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_AVAILABLE) landOwnership = STR_CONSTRUCTION_RIGHTS_SALE;
+            if (tileElement->properties.surface.ownership & OWNERSHIP_OWNED) landOwnership = STR_LAND_OWNED;
+            else if (tileElement->properties.surface.ownership & OWNERSHIP_AVAILABLE) landOwnership = STR_LAND_SALE;
+            else if (tileElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) landOwnership = STR_CONSTRUCTION_RIGHTS_OWNED;
+            else if (tileElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_AVAILABLE) landOwnership = STR_CONSTRUCTION_RIGHTS_SALE;
             else landOwnership = STR_TILE_INSPECTOR_LAND_NOT_OWNED_AND_NOT_AVAILABLE;
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SURFACE_OWNERSHIP, &landOwnership, COLOUR_DARK_GREEN, x, y + 22);
 
             // Water level
-            sint32 waterLevel = map_get_water_height(mapElement);
+            sint32 waterLevel = map_get_water_height(tileElement);
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SURFACE_WATER_LEVEL, &waterLevel, COLOUR_DARK_GREEN, x, y + 33);
 
             // Properties
@@ -1674,7 +1674,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_SURFACE_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
 
             // Raised corners
@@ -1687,12 +1687,12 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
         case TILE_INSPECTOR_PAGE_PATH: {
             // Details
             // Path name
-            rct_string_id pathNameId = get_footpath_entry(footpath_element_get_type(mapElement))->string_idx;
+            rct_string_id pathNameId = get_footpath_entry(footpath_element_get_type(tileElement))->string_idx;
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_PATH_NAME, &pathNameId, COLOUR_DARK_GREEN, x, y);
 
             // Path addition
-            if (footpath_element_has_path_scenery(mapElement)) {
-                const uint8 pathAdditionType = footpath_element_get_path_scenery_index(mapElement);
+            if (footpath_element_has_path_scenery(tileElement)) {
+                const uint8 pathAdditionType = footpath_element_get_path_scenery_index(tileElement);
                 rct_string_id additionNameId = get_footpath_item_entry(pathAdditionType)->name;
                 gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_PATH_ADDITIONS, &additionNameId, COLOUR_DARK_GREEN, x, y + 11);
             }
@@ -1707,7 +1707,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_PATH_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
 
             // Path connections
@@ -1720,7 +1720,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
         case TILE_INSPECTOR_PAGE_TRACK: {
             // Details
             // Ride
-            sint16 rideId = mapElement->properties.track.ride_index;
+            sint16 rideId = tileElement->properties.track.ride_index;
             Ride *ride = get_ride(rideId);
             rct_string_id rideType = RideNaming[ride->type].name;
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_TRACK_RIDE_TYPE, &rideType, COLOUR_DARK_GREEN, x, y);
@@ -1729,8 +1729,8 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
             set_format_arg(0 + sizeof(rct_string_id), uint32, ride->name_arguments);
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_TRACK_RIDE_NAME, gCommonFormatArgs, COLOUR_DARK_GREEN, x, y + 22);
             // Track
-            sint16 trackType = mapElement->properties.track.type;
-            sint16 sequenceNumber = tile_element_get_track_sequence(mapElement);
+            sint16 trackType = tileElement->properties.track.type;
+            sint16 sequenceNumber = tile_element_get_track_sequence(tileElement);
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_TRACK_PIECE_ID, &trackType, COLOUR_DARK_GREEN, x, y + 33);
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_TRACK_SEQUENCE, &sequenceNumber, COLOUR_DARK_GREEN, x, y + 44);
 
@@ -1741,7 +1741,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_TRACK_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
             break;
         }
@@ -1749,12 +1749,12 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
         case TILE_INSPECTOR_PAGE_SCENERY: {
             // Details
             // Age
-            sint16 age = mapElement->properties.scenery.age;
+            sint16 age = tileElement->properties.scenery.age;
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SCENERY_AGE, &age, COLOUR_DARK_GREEN, x, y);
 
             // Quadrant value
-            if (!(get_small_scenery_entry(mapElement->properties.scenery.type)->small_scenery.flags & SMALL_SCENERY_FLAG_FULL_TILE)) {
-                sint16 quadrant = (mapElement->type & TILE_ELEMENT_QUADRANT_MASK) >> 6;
+            if (!(get_small_scenery_entry(tileElement->properties.scenery.type)->small_scenery.flags & SMALL_SCENERY_FLAG_FULL_TILE)) {
+                sint16 quadrant = (tileElement->type & TILE_ELEMENT_QUADRANT_MASK) >> 6;
                 static rct_string_id quadrant_string_idx[] = {
                     STR_TILE_INSPECTOR_SCENERY_QUADRANT_SW,
                     STR_TILE_INSPECTOR_SCENERY_QUADRANT_NW,
@@ -1765,7 +1765,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
             }
 
             // Scenery ID
-            sint16 idx = mapElement->properties.scenery.type;
+            sint16 idx = tileElement->properties.scenery.type;
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_SCENERY_ENTRY_IDX, &idx, COLOUR_DARK_GREEN, x, y + 22);
 
             // Properties
@@ -1775,7 +1775,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_SCENERY_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
 
             // Quarter tile
@@ -1792,20 +1792,20 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
         case TILE_INSPECTOR_PAGE_ENTRANCE: {
             // Details
             // Entrance type
-            rct_string_id entranceType = EntranceTypeStringIds[mapElement->properties.entrance.type];
+            rct_string_id entranceType = EntranceTypeStringIds[tileElement->properties.entrance.type];
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRANCE_TYPE, &entranceType, COLOUR_DARK_GREEN, x, y);
 
-            if (mapElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE) {
+            if (tileElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE) {
                 // Park entrance ID
                 sint32 middleX = windowTileInspectorTileX << 5;
                 sint32 middleY = windowTileInspectorTileY << 5;
                 // TODO: Make this work with Left/Right park entrance parts
-                sint16 parkEntranceIndex = park_entrance_get_index(middleX, middleY, mapElement->base_height * 8);
+                sint16 parkEntranceIndex = park_entrance_get_index(middleX, middleY, tileElement->base_height * 8);
                 gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID, &parkEntranceIndex, COLOUR_DARK_GREEN, x, y + 11);
             }
             else {
-                sint16 rideEntranceIndex = (mapElement->properties.entrance.index & 0x30) >> 4;
-                if (mapElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
+                sint16 rideEntranceIndex = (tileElement->properties.entrance.index & 0x30) >> 4;
+                if (tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
                     // Ride entrance ID
                     gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID, &rideEntranceIndex, COLOUR_DARK_GREEN, x, y + 11);
                 }
@@ -1815,14 +1815,14 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
                 }
             }
 
-            if (mapElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE) {
+            if (tileElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE) {
                 // Entrance part
-                rct_string_id entrancePart = ParkEntrancePartStringIds[mapElement->properties.entrance.index & 0x0F];
+                rct_string_id entrancePart = ParkEntrancePartStringIds[tileElement->properties.entrance.index & 0x0F];
                 gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRANCE_PART, &entrancePart, COLOUR_DARK_GREEN, x, y + 22);
             }
             else {
                 // Ride ID
-                sint16 rideId = mapElement->properties.entrance.ride_index;
+                sint16 rideId = tileElement->properties.entrance.ride_index;
                 gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRANCE_RIDE_ID, &rideId, COLOUR_DARK_GREEN, x, y + 22);
             }
 
@@ -1833,7 +1833,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_ENTRANCE_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
             break;
         }
@@ -1841,13 +1841,13 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
         case TILE_INSPECTOR_PAGE_WALL: {
             // Details
             // Type
-            sint16 wallType = mapElement->properties.wall.type;
+            sint16 wallType = tileElement->properties.wall.type;
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_WALL_TYPE, &wallType, COLOUR_DARK_GREEN, x, y);
 
             // Banner info
             rct_wall_scenery_entry wallEntry = get_wall_entry(wallType)->wall;
             if (wallEntry.flags & WALL_SCENERY_IS_BANNER) {
-                gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, &gBanners[mapElement->properties.wall.banner_index].string_idx, COLOUR_DARK_GREEN, x, y + 11);
+                gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, &gBanners[tileElement->properties.wall.banner_index].string_idx, COLOUR_DARK_GREEN, x, y + 11);
             }
             else {
                 gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_NONE, nullptr, COLOUR_DARK_GREEN, x, y + 11);
@@ -1860,7 +1860,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_WALL_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
 
             // Slope label
@@ -1874,19 +1874,19 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
         {
             // Details
             // Type
-            sint16 largeSceneryType = mapElement->properties.scenerymultiple.type & 0x03FF;
+            sint16 largeSceneryType = tileElement->properties.scenerymultiple.type & 0x03FF;
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_LARGE_SCENERY_TYPE, &largeSceneryType, COLOUR_DARK_GREEN, x, y);
 
             // Part ID
-            sint16 pieceID = (mapElement->properties.scenerymultiple.type & 0xFC00) >> 10;
+            sint16 pieceID = (tileElement->properties.scenerymultiple.type & 0xFC00) >> 10;
             gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_LARGE_SCENERY_PIECE_ID, &pieceID, COLOUR_DARK_GREEN, x, y + 11);
 
             // Banner info
-            rct_scenery_entry *largeSceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
+            rct_scenery_entry *largeSceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK);
             if (largeSceneryEntry->large_scenery.scrolling_mode != 0xFF) {
-                const sint32 bannerIndex = (mapElement->type & 0xC0) |
-                    ((mapElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) |
-                    ((mapElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
+                const sint32 bannerIndex = (tileElement->type & 0xC0) |
+                    ((tileElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) |
+                    ((tileElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
                 //window_sign_open(bannerIndex);
                 gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, &gBanners[bannerIndex].string_idx, COLOUR_DARK_GREEN, x, y + 22);
             }
@@ -1901,7 +1901,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_LARGE_SCENERY_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
             break;
         }
@@ -1910,7 +1910,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
         {
             // Details
             // Banner info
-            const uint8 bannerIndex = mapElement->properties.banner.index;
+            const uint8 bannerIndex = tileElement->properties.banner.index;
             if (gBanners[bannerIndex].flags & BANNER_FLAG_NO_ENTRY) {
                 rct_string_id noEntryStringIdx = STR_NO_ENTRY;
                 gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT, &noEntryStringIdx, COLOUR_DARK_GREEN, x, y);
@@ -1926,7 +1926,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_BANNER_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
 
             // Blocked paths
@@ -1945,7 +1945,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
 
             // Current base height
             x = w->x + w->widgets[WIDX_CORRUPT_SPINNER_HEIGHT].left + 3;
-            sint32 baseHeight = mapElement->base_height;
+            sint32 baseHeight = tileElement->base_height;
             gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x, y);
             break;
         }
@@ -1962,14 +1962,14 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
     if (!windowTileInspectorTileSelected)
         return;
 
-    rct_tile_element *mapElement = map_get_first_element_at(windowTileInspectorTileX, windowTileInspectorTileY);
+    rct_tile_element *tileElement = map_get_first_element_at(windowTileInspectorTileX, windowTileInspectorTileY);
 
     gCurrentFontSpriteBase = FONT_SPRITE_BASE_MEDIUM;
     do {
-        sint32 type = tile_element_get_type(mapElement);
+        sint32 type = tile_element_get_type(tileElement);
         const char * typeName = "";
-        sint32 baseHeight = mapElement->base_height;
-        sint32 clearanceHeight = mapElement->clearance_height;
+        sint32 baseHeight = tileElement->base_height;
+        sint32 clearanceHeight = tileElement->clearance_height;
 
         // Fill colour for current list element
         const sint32 listWidth = w->widgets[WIDX_LIST].right - w->widgets[WIDX_LIST].left;
@@ -1985,7 +1985,7 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
             typeName = "Surface";
             break;
         case TILE_ELEMENT_TYPE_PATH:
-            typeName = footpath_element_is_queue(mapElement) ? "Queue" : "Footpath";
+            typeName = footpath_element_is_queue(tileElement) ? "Queue" : "Footpath";
             break;
         case TILE_ELEMENT_TYPE_TRACK:
             typeName = "Track";
@@ -1994,7 +1994,7 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
             snprintf(
                 buffer, sizeof(buffer),
                 "Scenery (%s)",
-                language_get_string(get_small_scenery_entry(mapElement->properties.scenery.type)->name)
+                language_get_string(get_small_scenery_entry(tileElement->properties.scenery.type)->name)
             );
             typeName = buffer;
             break;
@@ -2005,7 +2005,7 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
             snprintf(
                 buffer, sizeof(buffer),
                 "Wall (%s)",
-                language_get_string(get_wall_entry(mapElement->properties.scenery.type)->name)
+                language_get_string(get_wall_entry(tileElement->properties.scenery.type)->name)
             );
             typeName = buffer;
             break;
@@ -2016,7 +2016,7 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
             snprintf(
                 buffer, sizeof(buffer),
                 "Banner (%d)",
-                mapElement->properties.banner.index
+                tileElement->properties.banner.index
             );
             typeName = buffer;
             break;
@@ -2029,9 +2029,9 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
 
         // Undo relative scroll offset, but keep the 3 pixel padding
         sint32 x = -w->widgets[WIDX_LIST].left;
-        const bool ghost = (mapElement->flags & TILE_ELEMENT_FLAG_GHOST) != 0;
-        const bool broken = (mapElement->flags & TILE_ELEMENT_FLAG_BROKEN) != 0;
-        const bool last = (mapElement->flags & TILE_ELEMENT_FLAG_LAST_TILE) != 0;
+        const bool ghost = (tileElement->flags & TILE_ELEMENT_FLAG_GHOST) != 0;
+        const bool broken = (tileElement->flags & TILE_ELEMENT_FLAG_BROKEN) != 0;
+        const bool last = (tileElement->flags & TILE_ELEMENT_FLAG_LAST_TILE) != 0;
         gfx_clip_string(buffer, w->widgets[WIDX_COLUMN_TYPE].right - w->widgets[WIDX_COLUMN_TYPE].left - COL_X_TYPE);
         gfx_draw_string(dpi, (char *)typeName, COLOUR_DARK_GREEN, x + COL_X_TYPE + 3, y); // 3px padding
         gfx_draw_string_left(dpi, STR_FORMAT_INTEGER, &baseHeight, COLOUR_DARK_GREEN, x + COL_X_BH, y);
@@ -2042,5 +2042,5 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
 
         y -= LIST_ITEM_HEIGHT;
         i++;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 }
diff --git a/src/openrct2/windows/TopToolbar.cpp b/src/openrct2/windows/TopToolbar.cpp
index b487d880e4..45a72373f8 100644
--- a/src/openrct2/windows/TopToolbar.cpp
+++ b/src/openrct2/windows/TopToolbar.cpp
@@ -1038,21 +1038,21 @@ static void scenery_eyedropper_tool_down(sint16 x, sint16 y, rct_widgetindex wid
 
     sint16 gridX, gridY;
     sint32 type;
-    rct_tile_element* mapElement;
+    rct_tile_element* tileElement;
     rct_viewport * viewport;
-    get_map_coordinates_from_pos(x, y, flags, &gridX, &gridY, &type, &mapElement, &viewport);
+    get_map_coordinates_from_pos(x, y, flags, &gridX, &gridY, &type, &tileElement, &viewport);
 
     switch (type) {
     case VIEWPORT_INTERACTION_ITEM_SCENERY:
     {
-        sint32 entryIndex = mapElement->properties.scenery.type;
+        sint32 entryIndex = tileElement->properties.scenery.type;
         rct_scenery_entry * sceneryEntry = get_small_scenery_entry(entryIndex);
         if (sceneryEntry != nullptr) {
             sint32 sceneryId = get_scenery_id_from_entry_index(OBJECT_TYPE_SMALL_SCENERY, entryIndex);
             if (sceneryId != -1 && window_scenery_set_selected_item(sceneryId)) {
-                gWindowSceneryRotation = (get_current_rotation() + tile_element_get_direction(mapElement)) & 3;
-                gWindowSceneryPrimaryColour = mapElement->properties.scenery.colour_1 & 0x1F;
-                gWindowScenerySecondaryColour = mapElement->properties.scenery.colour_2 & 0x1F;
+                gWindowSceneryRotation = (get_current_rotation() + tile_element_get_direction(tileElement)) & 3;
+                gWindowSceneryPrimaryColour = tileElement->properties.scenery.colour_1 & 0x1F;
+                gWindowScenerySecondaryColour = tileElement->properties.scenery.colour_2 & 0x1F;
                 gWindowSceneryEyedropperEnabled = false;
             }
         }
@@ -1060,14 +1060,14 @@ static void scenery_eyedropper_tool_down(sint16 x, sint16 y, rct_widgetindex wid
     }
     case VIEWPORT_INTERACTION_ITEM_WALL:
     {
-        sint32 entryIndex = mapElement->properties.wall.type;
+        sint32 entryIndex = tileElement->properties.wall.type;
         rct_scenery_entry * sceneryEntry = get_wall_entry(entryIndex);
         if (sceneryEntry != nullptr) {
             sint32 sceneryId = get_scenery_id_from_entry_index(OBJECT_TYPE_WALLS, entryIndex);
             if (sceneryId != -1 && window_scenery_set_selected_item(sceneryId)) {
-                gWindowSceneryPrimaryColour = mapElement->properties.wall.colour_1 & 0x1F;
-                gWindowScenerySecondaryColour = wall_element_get_secondary_colour(mapElement);
-                gWindowSceneryTertiaryColour = mapElement->properties.wall.colour_3 & 0x1F;
+                gWindowSceneryPrimaryColour = tileElement->properties.wall.colour_1 & 0x1F;
+                gWindowScenerySecondaryColour = wall_element_get_secondary_colour(tileElement);
+                gWindowSceneryTertiaryColour = tileElement->properties.wall.colour_3 & 0x1F;
                 gWindowSceneryEyedropperEnabled = false;
             }
         }
@@ -1075,14 +1075,14 @@ static void scenery_eyedropper_tool_down(sint16 x, sint16 y, rct_widgetindex wid
     }
     case VIEWPORT_INTERACTION_ITEM_LARGE_SCENERY:
     {
-        sint32 entryIndex = mapElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK;
+        sint32 entryIndex = tileElement->properties.scenerymultiple.type & TILE_ELEMENT_LARGE_TYPE_MASK;
         rct_scenery_entry * sceneryEntry = get_large_scenery_entry(entryIndex);
         if (sceneryEntry != nullptr) {
             sint32 sceneryId = get_scenery_id_from_entry_index(OBJECT_TYPE_LARGE_SCENERY, entryIndex);
             if (sceneryId != -1 && window_scenery_set_selected_item(sceneryId)) {
-                gWindowSceneryRotation = (get_current_rotation() + tile_element_get_direction(mapElement)) & 3;
-                gWindowSceneryPrimaryColour = mapElement->properties.scenerymultiple.colour[0] & 0x1F;
-                gWindowScenerySecondaryColour = mapElement->properties.scenerymultiple.colour[1] & 0x1F;
+                gWindowSceneryRotation = (get_current_rotation() + tile_element_get_direction(tileElement)) & 3;
+                gWindowSceneryPrimaryColour = tileElement->properties.scenerymultiple.colour[0] & 0x1F;
+                gWindowScenerySecondaryColour = tileElement->properties.scenerymultiple.colour[1] & 0x1F;
                 gWindowSceneryEyedropperEnabled = false;
             }
         }
@@ -1090,7 +1090,7 @@ static void scenery_eyedropper_tool_down(sint16 x, sint16 y, rct_widgetindex wid
     }
     case VIEWPORT_INTERACTION_ITEM_BANNER:
     {
-        sint32 bannerIndex = mapElement->properties.banner.index;
+        sint32 bannerIndex = tileElement->properties.banner.index;
         rct_banner *banner = &gBanners[bannerIndex];
         rct_scenery_entry * sceneryEntry = get_banner_entry(banner->type);
         if (sceneryEntry != nullptr) {
@@ -1103,7 +1103,7 @@ static void scenery_eyedropper_tool_down(sint16 x, sint16 y, rct_widgetindex wid
     }
     case VIEWPORT_INTERACTION_ITEM_FOOTPATH_ITEM:
     {
-        sint32 entryIndex = footpath_element_get_path_scenery_index(mapElement);
+        sint32 entryIndex = footpath_element_get_path_scenery_index(tileElement);
         rct_scenery_entry * sceneryEntry = get_footpath_item_entry(entryIndex);
         if (sceneryEntry != nullptr) {
             sint32 sceneryId = get_scenery_id_from_entry_index(OBJECT_TYPE_PATH_BITS, entryIndex);
@@ -2195,7 +2195,7 @@ static money32 try_place_ghost_scenery(LocationXY16 map_tile, uint32 parameter_1
 
     uint8 scenery_type = (selected_tab & 0xFF00) >> 8;
     money32 cost = 0;
-    rct_tile_element* mapElement;
+    rct_tile_element* tileElement;
 
     switch (scenery_type){
     case 0:
@@ -2218,9 +2218,9 @@ static money32 try_place_ghost_scenery(LocationXY16 map_tile, uint32 parameter_1
         gSceneryPlaceRotation = (uint16)(parameter_3 & 0xFF);
         gSceneryPlaceObject = selected_tab;
 
-        mapElement = gSceneryMapElement;
-        gSceneryGhostPosition.z = mapElement->base_height;
-        gSceneryMapElementType = mapElement->type;
+        tileElement = gSceneryTileElement;
+        gSceneryGhostPosition.z = tileElement->base_height;
+        gSceneryTileElementType = tileElement->type;
         if (gSceneryGroundFlags & ELEMENT_IS_UNDERGROUND){
             //Set underground on
             viewport_set_visibility(4);
@@ -2281,8 +2281,8 @@ static money32 try_place_ghost_scenery(LocationXY16 map_tile, uint32 parameter_1
         gSceneryGhostPosition.y = map_tile.y;
         gSceneryGhostWallRotation = (parameter_2 & 0xFF);
 
-        mapElement = gSceneryMapElement;
-        gSceneryGhostPosition.z = mapElement->base_height;
+        tileElement = gSceneryTileElement;
+        gSceneryGhostPosition.z = tileElement->base_height;
 
         gSceneryGhostType |= (1 << 2);
         break;
@@ -2305,8 +2305,8 @@ static money32 try_place_ghost_scenery(LocationXY16 map_tile, uint32 parameter_1
         gSceneryGhostPosition.y = map_tile.y;
         gSceneryPlaceRotation = ((parameter_1 >> 8) & 0xFF);
 
-        mapElement = gSceneryMapElement;
-        gSceneryGhostPosition.z = mapElement->base_height;
+        tileElement = gSceneryTileElement;
+        gSceneryGhostPosition.z = tileElement->base_height;
 
         if (gSceneryGroundFlags & ELEMENT_IS_UNDERGROUND){
             //Set underground on
diff --git a/src/openrct2/world/Banner.cpp b/src/openrct2/world/Banner.cpp
index 244333de52..e71c877123 100644
--- a/src/openrct2/world/Banner.cpp
+++ b/src/openrct2/world/Banner.cpp
@@ -37,27 +37,27 @@ rct_banner gBanners[MAX_BANNERS];
  */
 static sint32 banner_get_ride_index_at(sint32 x, sint32 y, sint32 z)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     Ride *ride;
     sint32 rideIndex, resultRideIndex;
 
     resultRideIndex = -1;
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        rideIndex = mapElement->properties.track.ride_index;
+        rideIndex = tileElement->properties.track.ride_index;
         ride = get_ride(rideIndex);
         if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
             continue;
 
-        if ((mapElement->clearance_height * 8) + 32 <= z)
+        if ((tileElement->clearance_height * 8) + 32 <= z)
             continue;
 
         resultRideIndex = rideIndex;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return resultRideIndex;
 }
@@ -83,13 +83,13 @@ static money32 BannerRemove(sint16 x, sint16 y, uint8 baseHeight, uint8 directio
 
     // Slight modification to the code so that it now checks height as well
     // This was causing a bug with banners on two paths stacked.
-    rct_tile_element* mapElement = map_get_banner_element_at(x / 32, y / 32, baseHeight, direction);
-    if (mapElement == nullptr)
+    rct_tile_element* tileElement = map_get_banner_element_at(x / 32, y / 32, baseHeight, direction);
+    if (tileElement == nullptr)
     {
         return MONEY32_UNDEFINED;
     }
 
-    rct_banner *banner = &gBanners[mapElement->properties.banner.index];
+    rct_banner *banner = &gBanners[tileElement->properties.banner.index];
     rct_scenery_entry *bannerEntry = get_banner_entry(banner->type);
     money32 refund = 0;
     if (bannerEntry != nullptr)
@@ -108,9 +108,9 @@ static money32 BannerRemove(sint16 x, sint16 y, uint8 baseHeight, uint8 directio
             network_set_player_last_action_coord(network_get_player_index(game_command_playerid), coord);
         }
 
-        tile_element_remove_banner_entry(mapElement);
+        tile_element_remove_banner_entry(tileElement);
         map_invalidate_tile_zoom1(x, y, z, z + 32);
-        tile_element_remove(mapElement);
+        tile_element_remove(tileElement);
     }
 
     if (gParkFlags & PARK_FLAGS_NO_MONEY)
@@ -136,32 +136,32 @@ static money32 BannerSetColour(sint16 x, sint16 y, uint8 baseHeight, uint8 direc
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
     {
-        rct_tile_element* mapElement = map_get_first_element_at(x / 32, y / 32);
+        rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
 
         bool found = false;
         do
         {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_BANNER)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_BANNER)
                 continue;
 
-            if (mapElement->properties.banner.position != direction)
+            if (tileElement->properties.banner.position != direction)
                 continue;
 
             found = true;
             break;
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
 
         if (found == false)
         {
             return MONEY32_UNDEFINED;
         }
 
-        rct_window* window = window_find_by_number(WC_BANNER, mapElement->properties.banner.index);
+        rct_window* window = window_find_by_number(WC_BANNER, tileElement->properties.banner.index);
         if (window != nullptr)
         {
             window_invalidate(window);
         }
-        gBanners[mapElement->properties.banner.index].colour = colour;
+        gBanners[tileElement->properties.banner.index].colour = colour;
         map_invalidate_tile_zoom1(x, y, z, z + 32);
     }
 
@@ -190,23 +190,23 @@ static money32 BannerPlace(sint16 x, sint16 y, uint8 pathBaseHeight, uint8 direc
         return MONEY32_UNDEFINED;
     }
 
-    rct_tile_element* mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
 
     bool pathFound = false;
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        if (mapElement->base_height != pathBaseHeight * 2 && mapElement->base_height != (pathBaseHeight - 1) * 2)
+        if (tileElement->base_height != pathBaseHeight * 2 && tileElement->base_height != (pathBaseHeight - 1) * 2)
             continue;
 
-        if (!(mapElement->properties.path.edges & (1 << direction)))
+        if (!(tileElement->properties.path.edges & (1 << direction)))
             continue;
 
         pathFound = true;
         break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     if (pathFound == false)
     {
@@ -220,8 +220,8 @@ static money32 BannerPlace(sint16 x, sint16 y, uint8 pathBaseHeight, uint8 direc
     }
 
     uint8 baseHeight = (pathBaseHeight + 1) * 2;
-    mapElement = map_get_banner_element_at(x / 32, y / 32, baseHeight, direction);
-    if (mapElement != nullptr)
+    tileElement = map_get_banner_element_at(x / 32, y / 32, baseHeight, direction);
+    if (tileElement != nullptr)
     {
         gGameCommandErrorText = STR_BANNER_SIGN_IN_THE_WAY;
         return MONEY32_UNDEFINED;
@@ -244,24 +244,24 @@ static money32 BannerPlace(sint16 x, sint16 y, uint8 pathBaseHeight, uint8 direc
             network_set_player_last_action_coord(network_get_player_index(game_command_playerid), coord);
         }
 
-        rct_tile_element* newMapElement = tile_element_insert(x / 32, y / 32, baseHeight, 0);
-        assert(newMapElement != nullptr);
+        rct_tile_element* newTileElement = tile_element_insert(x / 32, y / 32, baseHeight, 0);
+        assert(newTileElement != nullptr);
         gBanners[*bannerIndex].type = type;
         gBanners[*bannerIndex].colour = colour;
         gBanners[*bannerIndex].x = x / 32;
         gBanners[*bannerIndex].y = y / 32;
-        newMapElement->type = TILE_ELEMENT_TYPE_BANNER;
-        newMapElement->clearance_height = newMapElement->base_height + 2;
-        newMapElement->properties.banner.position = direction;
-        newMapElement->properties.banner.flags = 0xFF;
-        newMapElement->properties.banner.unused = 0;
-        newMapElement->properties.banner.index = *bannerIndex;
+        newTileElement->type = TILE_ELEMENT_TYPE_BANNER;
+        newTileElement->clearance_height = newTileElement->base_height + 2;
+        newTileElement->properties.banner.position = direction;
+        newTileElement->properties.banner.flags = 0xFF;
+        newTileElement->properties.banner.unused = 0;
+        newTileElement->properties.banner.index = *bannerIndex;
         if (flags & GAME_COMMAND_FLAG_GHOST)
         {
-            newMapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
+            newTileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
         }
         map_invalidate_tile_full(x, y);
-        map_animation_create(MAP_ANIMATION_TYPE_BANNER, x, y, newMapElement->base_height);
+        map_animation_create(MAP_ANIMATION_TYPE_BANNER, x, y, newTileElement->base_height);
     }
 
     rct_scenery_entry *bannerEntry = get_banner_entry(type);
@@ -353,9 +353,9 @@ static money32 BannerSetStyle(uint8 bannerIndex, uint8 colour, uint8 textColour,
 
     rct_banner* banner = &gBanners[bannerIndex];
 
-    rct_tile_element* mapElement = banner_get_tile_element(bannerIndex);
+    rct_tile_element* tileElement = banner_get_tile_element(bannerIndex);
 
-    if (mapElement == nullptr)
+    if (tileElement == nullptr)
     {
         return MONEY32_UNDEFINED;
     }
@@ -369,10 +369,10 @@ static money32 BannerSetStyle(uint8 bannerIndex, uint8 colour, uint8 textColour,
     banner->text_colour = textColour;
     banner->flags = bannerFlags;
 
-    mapElement->properties.banner.flags = 0xFF;
+    tileElement->properties.banner.flags = 0xFF;
     if (banner->flags & BANNER_FLAG_NO_ENTRY)
     {
-        mapElement->properties.banner.flags &= ~(1 << mapElement->properties.banner.position);
+        tileElement->properties.banner.flags &= ~(1 << tileElement->properties.banner.position);
     }
 
     sint32 colourCodepoint = FORMAT_COLOUR_CODE_START + banner->text_colour;
@@ -470,14 +470,14 @@ extern "C"
     rct_tile_element *banner_get_tile_element(sint32 bannerIndex)
     {
         rct_banner *banner = &gBanners[bannerIndex];
-        rct_tile_element *mapElement = map_get_first_element_at(banner->x, banner->y);
+        rct_tile_element *tileElement = map_get_first_element_at(banner->x, banner->y);
         do
         {
-            if (tile_element_get_banner_index(mapElement) == bannerIndex)
+            if (tile_element_get_banner_index(tileElement) == bannerIndex)
             {
-                return mapElement;
+                return tileElement;
             }
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
         return nullptr;
     }
 
@@ -540,8 +540,8 @@ extern "C"
     {
         for (sint32 bannerIndex = 0; bannerIndex < MAX_BANNERS; bannerIndex++)
         {
-            rct_tile_element *mapElement = banner_get_tile_element(bannerIndex);
-            if (mapElement == nullptr)
+            rct_tile_element *tileElement = banner_get_tile_element(bannerIndex);
+            if (tileElement == nullptr)
                 gBanners[bannerIndex].type = BANNER_NULL;
         }
     }
diff --git a/src/openrct2/world/Duck.cpp b/src/openrct2/world/Duck.cpp
index 1cb1fc87f8..6e463e4714 100644
--- a/src/openrct2/world/Duck.cpp
+++ b/src/openrct2/world/Duck.cpp
@@ -125,8 +125,8 @@ void rct_duck::UpdateFlyToWater()
     sint32 newY = y + DuckMoveOffset[direction].y;
     sint32 manhattanDistanceN = abs(target_x - newX) + abs(target_y - newY);
 
-    rct_tile_element * mapElement = map_get_surface_element_at(target_x >> 5, target_y >> 5);
-    sint32 waterHeight = map_get_water_height(mapElement);
+    rct_tile_element * tileElement = map_get_surface_element_at(target_x >> 5, target_y >> 5);
+    sint32 waterHeight = map_get_water_height(tileElement);
     if (waterHeight == 0)
     {
         state = DUCK_STATE::FLY_AWAY;
diff --git a/src/openrct2/world/Entrance.cpp b/src/openrct2/world/Entrance.cpp
index 5491ed4148..03297df90a 100644
--- a/src/openrct2/world/Entrance.cpp
+++ b/src/openrct2/world/Entrance.cpp
@@ -37,16 +37,16 @@ uint8 gRideEntranceExitGhostStationIndex;
 
 static void ParkEntranceRemoveSegment(sint32 x, sint32 y, sint32 z)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_park_entrance_element_at(x, y, z, true);
-    if (mapElement == nullptr)
+    tileElement = map_get_park_entrance_element_at(x, y, z, true);
+    if (tileElement == nullptr)
     {
         return;
     }
 
-    map_invalidate_tile(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
-    tile_element_remove(mapElement);
+    map_invalidate_tile(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
+    tile_element_remove(tileElement);
     update_park_fences(x, y);
 }
 
@@ -281,17 +281,17 @@ static money32 RideEntranceExitPlace(sint16 x,
             coord.z = tile_element_height(coord.x, coord.y);
             network_set_player_last_action_coord(network_get_player_index(game_command_playerid), coord);
 
-            rct_tile_element* mapElement = tile_element_insert(x / 32, y / 32, z / 8, 0xF);
-            assert(mapElement != nullptr);
-            mapElement->clearance_height = clear_z;
-            mapElement->properties.entrance.type = isExit;
-            mapElement->properties.entrance.index = stationNum << 4;
-            mapElement->properties.entrance.ride_index = rideIndex;
-            mapElement->type = TILE_ELEMENT_TYPE_ENTRANCE | direction;
+            rct_tile_element* tileElement = tile_element_insert(x / 32, y / 32, z / 8, 0xF);
+            assert(tileElement != nullptr);
+            tileElement->clearance_height = clear_z;
+            tileElement->properties.entrance.type = isExit;
+            tileElement->properties.entrance.index = stationNum << 4;
+            tileElement->properties.entrance.ride_index = rideIndex;
+            tileElement->type = TILE_ELEMENT_TYPE_ENTRANCE | direction;
 
             if (flags & GAME_COMMAND_FLAG_GHOST)
             {
-                mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
+                tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
             }
 
             if (isExit)
@@ -313,10 +313,10 @@ static money32 RideEntranceExitPlace(sint16 x,
 
             if (!(flags & GAME_COMMAND_FLAG_GHOST))
             {
-                maze_entrance_hedge_removal(x, y, mapElement);
+                maze_entrance_hedge_removal(x, y, tileElement);
             }
 
-            footpath_connect_edges(x, y, mapElement, flags);
+            footpath_connect_edges(x, y, tileElement, flags);
             footpath_update_queue_chains();
 
             map_invalidate_tile_full(x, y);
@@ -372,8 +372,8 @@ static money32 RideEntranceExitRemove(sint16 x, sint16 y, uint8 rideIndex, uint8
         invalidate_test_results(rideIndex);
 
         bool found = false;
-        rct_tile_element* mapElement = map_get_first_element_at(x / 32, y / 32);
-        if (mapElement == nullptr)
+        rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
+        if (tileElement == nullptr)
         {
             log_warning("Invalid coordinates for entrance/exit removal x = %d, y = %d", x, y);
             return MONEY32_UNDEFINED;
@@ -381,19 +381,19 @@ static money32 RideEntranceExitRemove(sint16 x, sint16 y, uint8 rideIndex, uint8
 
         do
         {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
 
-            if (mapElement->base_height != ride->station_heights[stationNum])
+            if (tileElement->base_height != ride->station_heights[stationNum])
                 continue;
 
-            if (flags & GAME_COMMAND_FLAG_5 && !(mapElement->flags & TILE_ELEMENT_FLAG_GHOST))
+            if (flags & GAME_COMMAND_FLAG_5 && !(tileElement->flags & TILE_ELEMENT_FLAG_GHOST))
                 continue;
 
             found = true;
             break;
         }
-        while (!tile_element_is_last_for_tile(mapElement++));
+        while (!tile_element_is_last_for_tile(tileElement++));
 
         if (!found)
         {
@@ -407,12 +407,12 @@ static money32 RideEntranceExitRemove(sint16 x, sint16 y, uint8 rideIndex, uint8
         network_set_player_last_action_coord(network_get_player_index(game_command_playerid), coord);
 
         footpath_queue_chain_reset();
-        maze_entrance_hedge_replacement(x, y, mapElement);
-        footpath_remove_edges_at(x, y, mapElement);
+        maze_entrance_hedge_replacement(x, y, tileElement);
+        footpath_remove_edges_at(x, y, tileElement);
 
-        bool isExit = mapElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT;
+        bool isExit = tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT;
 
-        tile_element_remove(mapElement);
+        tile_element_remove(tileElement);
 
         if (isExit)
         {
@@ -620,68 +620,68 @@ extern "C"
      * Replaces the outer hedge walls for an entrance placement removal.
      *  rct2: 0x00666D6F
      */
-    void maze_entrance_hedge_replacement(sint32 x, sint32 y, rct_tile_element *mapElement)
+    void maze_entrance_hedge_replacement(sint32 x, sint32 y, rct_tile_element *tileElement)
     {
-        sint32 direction = tile_element_get_direction(mapElement);
+        sint32 direction = tile_element_get_direction(tileElement);
         x += TileDirectionDelta[direction].x;
         y += TileDirectionDelta[direction].y;
-        sint32 z = mapElement->base_height;
-        sint32 rideIndex = mapElement->properties.track.ride_index;
+        sint32 z = tileElement->base_height;
+        sint32 rideIndex = tileElement->properties.track.ride_index;
 
-        mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do {
-            if (mapElement->type != TILE_ELEMENT_TYPE_TRACK) continue;
-            if (mapElement->properties.track.ride_index != rideIndex) continue;
-            if (mapElement->base_height != z) continue;
-            if (mapElement->properties.track.type != TRACK_ELEM_MAZE) continue;
+            if (tileElement->type != TILE_ELEMENT_TYPE_TRACK) continue;
+            if (tileElement->properties.track.ride_index != rideIndex) continue;
+            if (tileElement->base_height != z) continue;
+            if (tileElement->properties.track.type != TRACK_ELEM_MAZE) continue;
 
             // Each maze element is split into 4 sections with 4 different walls
             uint8 mazeSection = direction * 4;
             // Add the top outer wall
-            mapElement->properties.track.maze_entry |= (1 << ((mazeSection + 9) & 0x0F));
+            tileElement->properties.track.maze_entry |= (1 << ((mazeSection + 9) & 0x0F));
             // Add the bottom outer wall
-            mapElement->properties.track.maze_entry |= (1 << ((mazeSection + 12) & 0x0F));
+            tileElement->properties.track.maze_entry |= (1 << ((mazeSection + 12) & 0x0F));
 
-            map_invalidate_tile(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+            map_invalidate_tile(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
             return;
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
     }
 
     /**
      * Removes the hedge walls for an entrance placement.
      *  rct2: 0x00666CBE
      */
-    void maze_entrance_hedge_removal(sint32 x, sint32 y, rct_tile_element *mapElement)
+    void maze_entrance_hedge_removal(sint32 x, sint32 y, rct_tile_element *tileElement)
     {
-        sint32 direction = tile_element_get_direction(mapElement);
+        sint32 direction = tile_element_get_direction(tileElement);
         x += TileDirectionDelta[direction].x;
         y += TileDirectionDelta[direction].y;
-        sint32 z = mapElement->base_height;
-        sint32 rideIndex = mapElement->properties.track.ride_index;
+        sint32 z = tileElement->base_height;
+        sint32 rideIndex = tileElement->properties.track.ride_index;
 
-        mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do {
-            if (mapElement->type != TILE_ELEMENT_TYPE_TRACK) continue;
-            if (mapElement->properties.track.ride_index != rideIndex) continue;
-            if (mapElement->base_height != z) continue;
-            if (mapElement->properties.track.type != TRACK_ELEM_MAZE) continue;
+            if (tileElement->type != TILE_ELEMENT_TYPE_TRACK) continue;
+            if (tileElement->properties.track.ride_index != rideIndex) continue;
+            if (tileElement->base_height != z) continue;
+            if (tileElement->properties.track.type != TRACK_ELEM_MAZE) continue;
 
             // Each maze element is split into 4 sections with 4 different walls
             uint8 mazeSection = direction * 4;
             // Remove the top outer wall
-            mapElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 9) & 0x0F));
+            tileElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 9) & 0x0F));
             // Remove the bottom outer wall
-            mapElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 12) & 0x0F));
+            tileElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 12) & 0x0F));
             // Remove the intersecting wall
-            mapElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 10) & 0x0F));
+            tileElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 10) & 0x0F));
             // Remove the top hedge section
-            mapElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 11) & 0x0F));
+            tileElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 11) & 0x0F));
             // Remove the bottom hedge section
-            mapElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 15) & 0x0F));
+            tileElement->properties.track.maze_entry &= ~(1 << ((mazeSection + 15) & 0x0F));
 
-            map_invalidate_tile(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+            map_invalidate_tile(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
             return;
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
     }
 
     void fix_park_entrance_locations(void)
diff --git a/src/openrct2/world/Fountain.cpp b/src/openrct2/world/Fountain.cpp
index ef057b2481..b4510b22e5 100644
--- a/src/openrct2/world/Fountain.cpp
+++ b/src/openrct2/world/Fountain.cpp
@@ -99,10 +99,10 @@ static void jumping_fountain_create_next(const rct_jumping_fountain * jumpingFou
 
 extern "C"
 {
-    void jumping_fountain_begin(sint32 type, sint32 x, sint32 y, const rct_tile_element * mapElement)
+    void jumping_fountain_begin(sint32 type, sint32 x, sint32 y, const rct_tile_element * tileElement)
     {
         sint32 randomIndex;
-        sint32 z = mapElement->base_height * 8;
+        sint32 z = tileElement->base_height * 8;
 
         // Change pattern approximately every 51 seconds
         uint32 pattern = (gCurrentTicks >> 11) & 7;
@@ -300,22 +300,22 @@ static bool is_jumping_fountain(sint32 type, sint32 x, sint32 y, sint32 z)
         PATH_BIT_FLAG_JUMPING_FOUNTAIN_SNOW :
         PATH_BIT_FLAG_JUMPING_FOUNTAIN_WATER;
 
-    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH) continue;
-        if (mapElement->base_height != z) continue;
-        if (footpath_element_path_scenery_is_ghost(mapElement)) continue;
-        if (!footpath_element_has_path_scenery(mapElement)) continue;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH) continue;
+        if (tileElement->base_height != z) continue;
+        if (footpath_element_path_scenery_is_ghost(tileElement)) continue;
+        if (!footpath_element_has_path_scenery(tileElement)) continue;
 
-        uint8 additionIndex = footpath_element_get_path_scenery_index(mapElement);
+        uint8 additionIndex = footpath_element_get_path_scenery_index(tileElement);
         rct_scenery_entry * sceneryEntry = get_footpath_item_entry(additionIndex);
         if (sceneryEntry != reinterpret_cast<void*>(-1) && sceneryEntry->path_bit.flags & pathBitFlagMask)
         {
             return true;
         }
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     return false;
 }
diff --git a/src/openrct2/world/Fountain.h b/src/openrct2/world/Fountain.h
index 1aa930cad5..5458cc148f 100644
--- a/src/openrct2/world/Fountain.h
+++ b/src/openrct2/world/Fountain.h
@@ -31,7 +31,7 @@ enum
 extern "C"
 {
 #endif
-    void jumping_fountain_begin(sint32 type, sint32 x, sint32 y, const rct_tile_element * mapElement);
+    void jumping_fountain_begin(sint32 type, sint32 x, sint32 y, const rct_tile_element * tileElement);
     void jumping_fountain_create(sint32 type, sint32 x, sint32 y, sint32 z, sint32 direction, sint32 flags, sint32 iteration);
     void jumping_fountain_update(rct_jumping_fountain * jumpingFountain);
 #ifdef __cplusplus
diff --git a/src/openrct2/world/SmallScenery.cpp b/src/openrct2/world/SmallScenery.cpp
index 2b2b76354a..78cea8324d 100644
--- a/src/openrct2/world/SmallScenery.cpp
+++ b/src/openrct2/world/SmallScenery.cpp
@@ -75,23 +75,23 @@ static money32 SmallSceneryRemove(sint16 x, sint16 y, uint8 baseHeight, uint8 qu
     }
 
     bool sceneryFound = false;
-    rct_tile_element* mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
             continue;
-        if ((mapElement->type >> 6) != quadrant)
+        if ((tileElement->type >> 6) != quadrant)
             continue;
-        if (mapElement->base_height != baseHeight)
+        if (tileElement->base_height != baseHeight)
             continue;
-        if (mapElement->properties.scenery.type != sceneryType)
+        if (tileElement->properties.scenery.type != sceneryType)
             continue;
         if ((flags & GAME_COMMAND_FLAG_GHOST) && 
-            !(mapElement->flags & TILE_ELEMENT_FLAG_GHOST))
+            !(tileElement->flags & TILE_ELEMENT_FLAG_GHOST))
             continue;
 
         sceneryFound = true;
         break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     if (sceneryFound == false)
     {
@@ -111,7 +111,7 @@ static money32 SmallSceneryRemove(sint16 x, sint16 y, uint8 baseHeight, uint8 qu
         }
 
         map_invalidate_tile_full(x, y);
-        tile_element_remove(mapElement);
+        tile_element_remove(tileElement);
     }
     return (gParkFlags & PARK_FLAGS_NO_MONEY) ? 0 : cost;
 }
@@ -132,22 +132,22 @@ static money32 SmallScenerySetColour(sint16 x, sint16 y, uint8 baseHeight, uint8
         }
     }
 
-    rct_tile_element *mapElement = map_get_small_scenery_element_at(x, y, baseHeight, sceneryType, quadrant);
+    rct_tile_element *tileElement = map_get_small_scenery_element_at(x, y, baseHeight, sceneryType, quadrant);
 
-    if (mapElement == nullptr)
+    if (tileElement == nullptr)
     {
         return 0;
     }
 
-    if ((flags & GAME_COMMAND_FLAG_GHOST) && !(mapElement->flags & TILE_ELEMENT_FLAG_GHOST))
+    if ((flags & GAME_COMMAND_FLAG_GHOST) && !(tileElement->flags & TILE_ELEMENT_FLAG_GHOST))
     {
         return 0;
     }
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
     {
-        scenery_small_set_primary_colour(mapElement, primaryColour);
-        scenery_small_set_secondary_colour(mapElement, secondaryColour);
+        scenery_small_set_primary_colour(tileElement, primaryColour);
+        scenery_small_set_secondary_colour(tileElement, secondaryColour);
 
         map_invalidate_tile_full(x, y);
     }
@@ -407,7 +407,7 @@ static money32 SmallSceneryPlace(sint16 x,
 
     rct_tile_element* newElement = tile_element_insert(x / 32, y / 32, zLow, collisionQuadrants);
     assert(newElement != nullptr);
-    gSceneryMapElement = newElement;
+    gSceneryTileElement = newElement;
     uint8 type = quadrant << 6;
     type |= TILE_ELEMENT_TYPE_SCENERY;
     type |= rotation;
diff --git a/src/openrct2/world/Wall.cpp b/src/openrct2/world/Wall.cpp
index 2e2f1c3130..8457a46199 100644
--- a/src/openrct2/world/Wall.cpp
+++ b/src/openrct2/world/Wall.cpp
@@ -184,68 +184,68 @@ static bool WallCheckObstruction(rct_scenery_entry * wall,
         return false;
     }
 
-    rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        sint32 elementType = tile_element_get_type(mapElement);
+        sint32 elementType = tile_element_get_type(tileElement);
         if (elementType == TILE_ELEMENT_TYPE_SURFACE) continue;
-        if (z0 >= mapElement->clearance_height) continue;
-        if (z1 <= mapElement->base_height) continue;
+        if (z0 >= tileElement->clearance_height) continue;
+        if (z1 <= tileElement->base_height) continue;
         if (elementType == TILE_ELEMENT_TYPE_WALL)
         {
-            sint32 direction = tile_element_get_direction(mapElement);
+            sint32 direction = tile_element_get_direction(tileElement);
             if (edge == direction)
             {
-                map_obstruction_set_error_text(mapElement);
+                map_obstruction_set_error_text(tileElement);
                 return false;
             }
             continue;
         }
-        if ((mapElement->flags & 0x0F) == 0) continue;
+        if ((tileElement->flags & 0x0F) == 0) continue;
 
         switch (elementType) {
         case TILE_ELEMENT_TYPE_ENTRANCE:
-            map_obstruction_set_error_text(mapElement);
+            map_obstruction_set_error_text(tileElement);
             return false;
         case TILE_ELEMENT_TYPE_PATH:
-            if (mapElement->properties.path.edges & (1 << edge))
+            if (tileElement->properties.path.edges & (1 << edge))
             {
-                map_obstruction_set_error_text(mapElement);
+                map_obstruction_set_error_text(tileElement);
                 return false;
             }
             break;
         case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
-            entryType = mapElement->properties.scenerymultiple.type & 0x3FF;
-            sequence = mapElement->properties.scenerymultiple.type >> 10;
+            entryType = tileElement->properties.scenerymultiple.type & 0x3FF;
+            sequence = tileElement->properties.scenerymultiple.type >> 10;
             entry = get_large_scenery_entry(entryType);
             tile = &entry->large_scenery.tiles[sequence];
             {
-                sint32 direction = ((edge - tile_element_get_direction(mapElement)) & TILE_ELEMENT_DIRECTION_MASK) + 8;
+                sint32 direction = ((edge - tile_element_get_direction(tileElement)) & TILE_ELEMENT_DIRECTION_MASK) + 8;
                 if (!(tile->var_7 & (1 << direction)))
                 {
-                    map_obstruction_set_error_text(mapElement);
+                    map_obstruction_set_error_text(tileElement);
                     return false;
                 }
             }
             break;
         case TILE_ELEMENT_TYPE_SCENERY:
-            entryType = mapElement->properties.scenery.type;
+            entryType = tileElement->properties.scenery.type;
             entry = get_small_scenery_entry(entryType);
             if (entry->small_scenery.flags & SMALL_SCENERY_FLAG_ALLOW_WALLS)
             {
-                map_obstruction_set_error_text(mapElement);
+                map_obstruction_set_error_text(tileElement);
                 return false;
             }
             break;
         case TILE_ELEMENT_TYPE_TRACK:
-            if (!WallCheckObstructionWithTrack(wall, x, y, z0, z1, edge, mapElement, wallAcrossTrack))
+            if (!WallCheckObstructionWithTrack(wall, x, y, z0, z1, edge, tileElement, wallAcrossTrack))
             {
                 return false;
             }
             break;
         }
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -529,41 +529,41 @@ static money32 WallPlace(uint8 wallType,
             network_set_player_last_action_coord(network_get_player_index(game_command_playerid), coord);
         }
 
-        rct_tile_element * mapElement = tile_element_insert(position.x / 32, position.y / 32, position.z / 8, 0);
-        assert(mapElement != nullptr);
+        rct_tile_element * tileElement = tile_element_insert(position.x / 32, position.y / 32, position.z / 8, 0);
+        assert(tileElement != nullptr);
 
         map_animation_create(MAP_ANIMATION_TYPE_WALL, position.x, position.y, position.z / 8);
 
-        mapElement->clearance_height = clearanceHeight;
+        tileElement->clearance_height = clearanceHeight;
 
-        mapElement->type = edgeSlope | edge | TILE_ELEMENT_TYPE_WALL;
+        tileElement->type = edgeSlope | edge | TILE_ELEMENT_TYPE_WALL;
 
-        mapElement->properties.wall.colour_1 = primaryColour;
-        wall_element_set_secondary_colour(mapElement, secondaryColour);
+        tileElement->properties.wall.colour_1 = primaryColour;
+        wall_element_set_secondary_colour(tileElement, secondaryColour);
 
         if (wallAcrossTrack)
         {
-            mapElement->properties.wall.animation |= WALL_ANIMATION_FLAG_ACROSS_TRACK;
+            tileElement->properties.wall.animation |= WALL_ANIMATION_FLAG_ACROSS_TRACK;
         }
 
-        mapElement->properties.wall.type = wallType;
+        tileElement->properties.wall.type = wallType;
         if (bannerIndex != 0xFF)
         {
-            mapElement->properties.wall.banner_index = bannerIndex;
+            tileElement->properties.wall.banner_index = bannerIndex;
         }
 
         if (wallEntry->wall.flags & WALL_SCENERY_HAS_TERNARY_COLOUR)
         {
-            mapElement->properties.wall.colour_3 = tertiaryColour;
+            tileElement->properties.wall.colour_3 = tertiaryColour;
         }
 
         if (flags & GAME_COMMAND_FLAG_GHOST)
         {
-            mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
+            tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
         }
 
-        gSceneryMapElement = mapElement;
-        map_invalidate_tile_zoom1(position.x, position.y, mapElement->base_height * 8, mapElement->base_height * 8 + 72);
+        gSceneryTileElement = tileElement;
+        map_invalidate_tile_zoom1(position.x, position.y, tileElement->base_height * 8, tileElement->base_height * 8 + 72);
     }
 
     if (gParkFlags & PARK_FLAGS_NO_MONEY)
@@ -578,16 +578,16 @@ static money32 WallPlace(uint8 wallType,
 
 static rct_tile_element * GetFirstWallElementAt(sint32 x, sint32 y, uint8 baseZ, uint8 direction, bool isGhost)
 {
-    rct_tile_element * mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL) continue;
-        if (mapElement->base_height != baseZ) continue;
-        if ((tile_element_get_direction(mapElement)) != direction) continue;
-        if (tile_element_is_ghost(mapElement) != isGhost) continue;
-        return mapElement;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL) continue;
+        if (tileElement->base_height != baseZ) continue;
+        if ((tile_element_get_direction(tileElement)) != direction) continue;
+        if (tile_element_is_ghost(tileElement) != isGhost) continue;
+        return tileElement;
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
     return nullptr;
 }
 
@@ -722,27 +722,27 @@ extern "C"
      */
     void wall_remove_at(sint32 x, sint32 y, sint32 z0, sint32 z1)
     {
-        rct_tile_element * mapElement;
+        rct_tile_element * tileElement;
 
         z0 /= 8;
         z1 /= 8;
     repeat:
-        mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do
         {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
                 continue;
-            if (z0 >= mapElement->clearance_height)
+            if (z0 >= tileElement->clearance_height)
                 continue;
-            if (z1 <= mapElement->base_height)
+            if (z1 <= tileElement->base_height)
                 continue;
 
-            tile_element_remove_banner_entry(mapElement);
-            map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->base_height * 8 + 72);
-            tile_element_remove(mapElement);
+            tile_element_remove_banner_entry(tileElement);
+            map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->base_height * 8 + 72);
+            tile_element_remove(tileElement);
             goto repeat;
         }
-        while (!tile_element_is_last_for_tile(mapElement++));
+        while (!tile_element_is_last_for_tile(tileElement++));
     }
 
     /**
@@ -760,26 +760,26 @@ extern "C"
      */
     void wall_remove_intersecting_walls(sint32 x, sint32 y, sint32 z0, sint32 z1, sint32 direction)
     {
-        rct_tile_element * mapElement;
+        rct_tile_element * tileElement;
 
-        mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do
         {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
                 continue;
 
-            if (mapElement->clearance_height <= z0 || mapElement->base_height >= z1)
+            if (tileElement->clearance_height <= z0 || tileElement->base_height >= z1)
                 continue;
 
-            if (direction != tile_element_get_direction(mapElement))
+            if (direction != tile_element_get_direction(tileElement))
                 continue;
 
-            tile_element_remove_banner_entry(mapElement);
-            map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->base_height * 8 + 72);
-            tile_element_remove(mapElement);
-            mapElement--;
+            tile_element_remove_banner_entry(tileElement);
+            map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->base_height * 8 + 72);
+            tile_element_remove(tileElement);
+            tileElement--;
         }
-        while (!tile_element_is_last_for_tile(mapElement++));
+        while (!tile_element_is_last_for_tile(tileElement++));
     }
 
     /**
diff --git a/src/openrct2/world/entrance.h b/src/openrct2/world/entrance.h
index d405bfa108..a3147d9fd8 100644
--- a/src/openrct2/world/entrance.h
+++ b/src/openrct2/world/entrance.h
@@ -55,8 +55,8 @@ money32 park_entrance_place_ghost(sint32 x, sint32 y, sint32 z, sint32 direction
 money32 place_park_entrance(sint16 x, sint16 y, sint16 z, uint8 direction);
 
 void reset_park_entrance();
-void maze_entrance_hedge_replacement(sint32 x, sint32 y, rct_tile_element *mapElement);
-void maze_entrance_hedge_removal(sint32 x, sint32 y, rct_tile_element *mapElement);
+void maze_entrance_hedge_replacement(sint32 x, sint32 y, rct_tile_element *tileElement);
+void maze_entrance_hedge_removal(sint32 x, sint32 y, rct_tile_element *tileElement);
 
 void fix_park_entrance_locations();
 
diff --git a/src/openrct2/world/footpath.c b/src/openrct2/world/footpath.c
index 410e6fa934..0b8ffa7f61 100644
--- a/src/openrct2/world/footpath.c
+++ b/src/openrct2/world/footpath.c
@@ -26,7 +26,7 @@
 #include "../util/util.h"
 
 void footpath_interrupt_peeps(sint32 x, sint32 y, sint32 z);
-void footpath_update_queue_entrance_banner(sint32 x, sint32 y, rct_tile_element *mapElement);
+void footpath_update_queue_entrance_banner(sint32 x, sint32 y, rct_tile_element *tileElement);
 
 uint8 gFootpathProvisionalFlags;
 LocationXYZ16 gFootpathProvisionalPosition;
@@ -80,16 +80,16 @@ static const uint8 connected_path_count[] = {
     4, // 0b1111
 };
 
-sint32 entrance_get_directions(rct_tile_element *mapElement)
+sint32 entrance_get_directions(rct_tile_element *tileElement)
 {
-    uint8 entranceType = mapElement->properties.entrance.type;
-    uint8 sequence = mapElement->properties.entrance.index & 0x0F;
+    uint8 entranceType = tileElement->properties.entrance.type;
+    uint8 sequence = tileElement->properties.entrance.index & 0x0F;
     return EntranceDirections[(entranceType * 8) + sequence];
 }
 
-static bool entrance_has_direction(rct_tile_element *mapElement, sint32 direction)
+static bool entrance_has_direction(rct_tile_element *tileElement, sint32 direction)
 {
-    return entrance_get_directions(mapElement) & (1 << direction);
+    return entrance_get_directions(tileElement) & (1 << direction);
 }
 
 /**
@@ -120,47 +120,47 @@ static void automatically_set_peep_spawn(sint32 x, sint32 y, sint32 z)
 
 static rct_tile_element *map_get_footpath_element(sint32 x, sint32 y, sint32 z)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x, y);
+    tileElement = map_get_first_element_at(x, y);
     do {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH && mapElement->base_height == z)
-            return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH && tileElement->base_height == z)
+            return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
 
 static rct_tile_element *map_get_footpath_element_slope(sint32 x, sint32 y, sint32 z, sint32 slope)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x, y);
+    tileElement = map_get_first_element_at(x, y);
     do {
         if (
-            tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH &&
-            mapElement->base_height == z &&
-            (mapElement->properties.path.type & 7) == slope
+            tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH &&
+            tileElement->base_height == z &&
+            (tileElement->properties.path.type & 7) == slope
         ) {
-            return mapElement;
+            return tileElement;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
 
-static void loc_6A6620(sint32 flags, sint32 x, sint32 y, rct_tile_element *mapElement)
+static void loc_6A6620(sint32 flags, sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    if ((mapElement->properties.path.type & 4) && !(flags & GAME_COMMAND_FLAG_GHOST)) {
-        sint32 direction = mapElement->properties.path.type & 3;
-        sint32 z = mapElement->base_height;
+    if ((tileElement->properties.path.type & 4) && !(flags & GAME_COMMAND_FLAG_GHOST)) {
+        sint32 direction = tileElement->properties.path.type & 3;
+        sint32 z = tileElement->base_height;
         wall_remove_intersecting_walls(x, y, z, z + 6, direction ^ 2);
         wall_remove_intersecting_walls(x, y, z, z + 6, direction);
-        mapElement = map_get_footpath_element(x / 32, y / 32, z);
+        tileElement = map_get_footpath_element(x / 32, y / 32, z);
     }
 
     if (!(flags & GAME_COMMAND_FLAG_PATH_SCENERY))
-        footpath_connect_edges(x, y, mapElement, flags);
+        footpath_connect_edges(x, y, tileElement, flags);
 
     footpath_update_queue_chains();
     map_invalidate_tile_full(x, y);
@@ -173,7 +173,7 @@ static const uint8 byte_98D7EC[] = {
 
 static money32 footpath_element_insert(sint32 type, sint32 x, sint32 y, sint32 z, sint32 slope, sint32 flags, uint8 pathItemType)
 {
-    rct_tile_element * mapElement, * entranceElement;
+    rct_tile_element * tileElement, * entranceElement;
     sint32 bl, zHigh;
     bool entrancePath = false, entranceIsSamePath = false;
 
@@ -214,9 +214,9 @@ static money32 footpath_element_insert(sint32 type, sint32 x, sint32 y, sint32 z
         return MONEY32_UNDEFINED;
     }
 
-    mapElement = map_get_surface_element_at((x / 32), (y / 32));
+    tileElement = map_get_surface_element_at((x / 32), (y / 32));
 
-    sint32 supportHeight = z - mapElement->base_height;
+    sint32 supportHeight = z - tileElement->base_height;
     gFootpathPrice += supportHeight < 0 ? MONEY(20, 00) : (supportHeight / 2) * MONEY(5, 00);
 
     if (flags & GAME_COMMAND_FLAG_APPLY) {
@@ -231,27 +231,27 @@ static money32 footpath_element_insert(sint32 type, sint32 x, sint32 y, sint32 z
         }
         else
         {
-            mapElement = tile_element_insert(x / 32, y / 32, z, 0x0F);
-            assert(mapElement != NULL);
-            mapElement->type = TILE_ELEMENT_TYPE_PATH;
-            mapElement->clearance_height = z + 4 + ((slope & 4) ? 2 : 0);
-            mapElement->properties.path.type = (type << 4) | (slope & 7);
-            mapElement->type |= type >> 7;
-            mapElement->properties.path.additions = pathItemType;
-            mapElement->properties.path.addition_status = 255;
-            mapElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
+            tileElement = tile_element_insert(x / 32, y / 32, z, 0x0F);
+            assert(tileElement != NULL);
+            tileElement->type = TILE_ELEMENT_TYPE_PATH;
+            tileElement->clearance_height = z + 4 + ((slope & 4) ? 2 : 0);
+            tileElement->properties.path.type = (type << 4) | (slope & 7);
+            tileElement->type |= type >> 7;
+            tileElement->properties.path.additions = pathItemType;
+            tileElement->properties.path.addition_status = 255;
+            tileElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
             if (flags & GAME_COMMAND_FLAG_GHOST)
-                mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
+                tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
 
             footpath_queue_chain_reset();
 
             if (!(flags & GAME_COMMAND_FLAG_PATH_SCENERY))
-                footpath_remove_edges_at(x, y, mapElement);
+                footpath_remove_edges_at(x, y, tileElement);
 
             if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !(flags & GAME_COMMAND_FLAG_GHOST))
-                automatically_set_peep_spawn(x, y, mapElement->base_height / 2);
+                automatically_set_peep_spawn(x, y, tileElement->base_height / 2);
 
-            loc_6A6620(flags, x, y, mapElement);
+            loc_6A6620(flags, x, y, tileElement);
         }
     }
 
@@ -262,15 +262,15 @@ static money32 footpath_element_insert(sint32 type, sint32 x, sint32 y, sint32 z
     return gParkFlags & PARK_FLAGS_NO_MONEY ? 0 : gFootpathPrice;
 }
 
-static money32 footpath_element_update(sint32 x, sint32 y, rct_tile_element *mapElement, sint32 type, sint32 flags, uint8 pathItemType)
+static money32 footpath_element_update(sint32 x, sint32 y, rct_tile_element *tileElement, sint32 type, sint32 flags, uint8 pathItemType)
 {
-    if ((mapElement->properties.path.type >> 4) != (type & 0x0F) || (mapElement->type & 1) != (type >> 7)) {
+    if ((tileElement->properties.path.type >> 4) != (type & 0x0F) || (tileElement->type & 1) != (type >> 7)) {
         gFootpathPrice += MONEY(6, 00);
     } else if (pathItemType != 0) {
         if (
             !(flags & GAME_COMMAND_FLAG_GHOST) &&
-            footpath_element_get_path_scenery(mapElement) == pathItemType &&
-            !(mapElement->flags & TILE_ELEMENT_FLAG_BROKEN)
+            footpath_element_get_path_scenery(tileElement) == pathItemType &&
+            !(tileElement->flags & TILE_ELEMENT_FLAG_BROKEN)
         ) {
             if (flags & GAME_COMMAND_FLAG_4)
                 return MONEY32_UNDEFINED;
@@ -282,22 +282,22 @@ static money32 footpath_element_update(sint32 x, sint32 y, rct_tile_element *map
             rct_scenery_entry* scenery_entry = get_footpath_item_entry(pathItemType - 1);
             uint16 unk6 = scenery_entry->path_bit.flags;
 
-            if ((unk6 & PATH_BIT_FLAG_DONT_ALLOW_ON_SLOPE) && footpath_element_is_sloped(mapElement)) {
+            if ((unk6 & PATH_BIT_FLAG_DONT_ALLOW_ON_SLOPE) && footpath_element_is_sloped(tileElement)) {
                 gGameCommandErrorText = STR_CANT_BUILD_THIS_ON_SLOPED_FOOTPATH;
                 return MONEY32_UNDEFINED;
             }
 
-            if ((unk6 & PATH_BIT_FLAG_DONT_ALLOW_ON_QUEUE) && footpath_element_is_queue(mapElement)) {
+            if ((unk6 & PATH_BIT_FLAG_DONT_ALLOW_ON_QUEUE) && footpath_element_is_queue(tileElement)) {
                 gGameCommandErrorText = STR_CANNOT_PLACE_THESE_ON_QUEUE_LINE_AREA;
                 return MONEY32_UNDEFINED;
             }
 
-            if (!(unk6 & (PATH_BIT_FLAG_JUMPING_FOUNTAIN_WATER | PATH_BIT_FLAG_JUMPING_FOUNTAIN_SNOW)) && (mapElement->properties.path.edges & 0x0F) == 0x0F) {
+            if (!(unk6 & (PATH_BIT_FLAG_JUMPING_FOUNTAIN_WATER | PATH_BIT_FLAG_JUMPING_FOUNTAIN_SNOW)) && (tileElement->properties.path.edges & 0x0F) == 0x0F) {
                 gGameCommandErrorText = STR_NONE;
                 return MONEY32_UNDEFINED;
             }
 
-            if ((unk6 & PATH_BIT_FLAG_IS_QUEUE_SCREEN) && !footpath_element_is_queue(mapElement)) {
+            if ((unk6 & PATH_BIT_FLAG_IS_QUEUE_SCREEN) && !footpath_element_is_queue(tileElement)) {
                 gGameCommandErrorText = STR_CAN_ONLY_PLACE_THESE_ON_QUEUE_AREA;
                 return MONEY32_UNDEFINED;
             }
@@ -311,14 +311,14 @@ static money32 footpath_element_update(sint32 x, sint32 y, rct_tile_element *map
         // Should place a ghost?
         if (flags & GAME_COMMAND_FLAG_GHOST) {
             // Check if there is something on the path already
-            if (footpath_element_has_path_scenery(mapElement)) {
+            if (footpath_element_has_path_scenery(tileElement)) {
                 gGameCommandErrorText = STR_NONE;
                 return MONEY32_UNDEFINED;
             }
 
             // There is nothing yet - check if we should place a ghost
             if (flags & GAME_COMMAND_FLAG_APPLY)
-                footpath_scenery_set_is_ghost(mapElement, true);
+                footpath_scenery_set_is_ghost(tileElement, true);
         }
 
         if (!(flags & GAME_COMMAND_FLAG_APPLY))
@@ -326,17 +326,17 @@ static money32 footpath_element_update(sint32 x, sint32 y, rct_tile_element *map
 
         if (
             (pathItemType != 0 && !(flags & GAME_COMMAND_FLAG_GHOST)) ||
-            (pathItemType == 0 && footpath_element_path_scenery_is_ghost(mapElement))
+            (pathItemType == 0 && footpath_element_path_scenery_is_ghost(tileElement))
         ) {
-            footpath_scenery_set_is_ghost(mapElement, false);
+            footpath_scenery_set_is_ghost(tileElement, false);
         }
 
-        footpath_element_set_path_scenery(mapElement, pathItemType);
-        mapElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
+        footpath_element_set_path_scenery(tileElement, pathItemType);
+        tileElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
         if (pathItemType != 0) {
             rct_scenery_entry* scenery_entry = get_footpath_item_entry(pathItemType - 1);
             if (scenery_entry->path_bit.flags & PATH_BIT_FLAG_IS_BIN) {
-                mapElement->properties.path.addition_status = 255;
+                tileElement->properties.path.addition_status = 255;
             }
         }
         map_invalidate_tile_full(x, y);
@@ -350,14 +350,14 @@ static money32 footpath_element_update(sint32 x, sint32 y, rct_tile_element *map
         footpath_queue_chain_reset();
 
         if (!(flags & GAME_COMMAND_FLAG_PATH_SCENERY))
-            footpath_remove_edges_at(x, y, mapElement);
+            footpath_remove_edges_at(x, y, tileElement);
 
-        mapElement->properties.path.type = (mapElement->properties.path.type & 0x0F) | (type << 4);
-        mapElement->type = (mapElement->type & 0xFE) | (type >> 7);
-        footpath_element_set_path_scenery(mapElement, pathItemType);
-        mapElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
+        tileElement->properties.path.type = (tileElement->properties.path.type & 0x0F) | (type << 4);
+        tileElement->type = (tileElement->type & 0xFE) | (type >> 7);
+        footpath_element_set_path_scenery(tileElement, pathItemType);
+        tileElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
 
-        loc_6A6620(flags, x, y, mapElement);
+        loc_6A6620(flags, x, y, tileElement);
     }
 
     return gParkFlags & PARK_FLAGS_NO_MONEY ? 0 : gFootpathPrice;
@@ -365,7 +365,7 @@ static money32 footpath_element_update(sint32 x, sint32 y, rct_tile_element *map
 
 static money32 footpath_place_real(sint32 type, sint32 x, sint32 y, sint32 z, sint32 slope, sint32 flags, uint8 pathItemType, bool clearDirection, sint32 direction)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     gCommandExpenditureType = RCT_EXPENDITURE_TYPE_LANDSCAPING;
     gCommandPosition.x = x + 16;
@@ -430,11 +430,11 @@ static money32 footpath_place_real(sint32 type, sint32 x, sint32 y, sint32 z, si
     }
 
     footpath_provisional_remove();
-    mapElement = map_get_footpath_element_slope((x / 32), (y / 32), z, slope);
-    if (mapElement == NULL) {
+    tileElement = map_get_footpath_element_slope((x / 32), (y / 32), z, slope);
+    if (tileElement == NULL) {
         return footpath_element_insert(type, x, y, z, slope, flags, pathItemType);
     } else {
-        return footpath_element_update(x, y, mapElement, type, flags, pathItemType);
+        return footpath_element_update(x, y, tileElement, type, flags, pathItemType);
     }
 }
 
@@ -442,19 +442,19 @@ static money32 footpath_place_real(sint32 type, sint32 x, sint32 y, sint32 z, si
  *
  *  rct2: 0x006BA23E
  */
-static void remove_banners_at_element(sint32 x, sint32 y, rct_tile_element* mapElement){
-    while (!tile_element_is_last_for_tile(mapElement++)){
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)return;
-        else if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_BANNER)continue;
+static void remove_banners_at_element(sint32 x, sint32 y, rct_tile_element* tileElement){
+    while (!tile_element_is_last_for_tile(tileElement++)){
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)return;
+        else if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_BANNER)continue;
 
-        game_do_command(x, 1, y, mapElement->base_height | mapElement->properties.banner.position << 8, GAME_COMMAND_REMOVE_BANNER, 0, 0);
-        mapElement--;
+        game_do_command(x, 1, y, tileElement->base_height | tileElement->properties.banner.position << 8, GAME_COMMAND_REMOVE_BANNER, 0, 0);
+        tileElement--;
     }
 }
 
 money32 footpath_remove_real(sint32 x, sint32 y, sint32 z, sint32 flags)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_tile_element *footpathElement = NULL;
 
     gCommandExpenditureType = RCT_EXPENDITURE_TYPE_LANDSCAPING;
@@ -475,8 +475,8 @@ money32 footpath_remove_real(sint32 x, sint32 y, sint32 z, sint32 flags)
     if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) && !map_is_location_owned(x, y, z * 8))
         return MONEY32_UNDEFINED;
 
-    mapElement = map_get_footpath_element(x / 32, y / 32, z);
-    if (mapElement != NULL && (flags & GAME_COMMAND_FLAG_APPLY)) {
+    tileElement = map_get_footpath_element(x / 32, y / 32, z);
+    if (tileElement != NULL && (flags & GAME_COMMAND_FLAG_APPLY)) {
         if (gGameCommandNestLevel == 1 && !(flags & GAME_COMMAND_FLAG_GHOST)) {
             LocationXYZ16 coord;
             coord.x = x + 16;
@@ -487,16 +487,16 @@ money32 footpath_remove_real(sint32 x, sint32 y, sint32 z, sint32 flags)
 
         // If the ghost flag is present we have to make sure to only delete ghost footpaths as they may be
         // at the same origin.
-        if ((flags & GAME_COMMAND_FLAG_GHOST) && tile_element_is_ghost(mapElement) == false) {
-            while (!tile_element_is_last_for_tile(mapElement++)) {
-                if (mapElement->type != TILE_ELEMENT_TYPE_PATH && !tile_element_is_ghost(mapElement)) {
+        if ((flags & GAME_COMMAND_FLAG_GHOST) && tile_element_is_ghost(tileElement) == false) {
+            while (!tile_element_is_last_for_tile(tileElement++)) {
+                if (tileElement->type != TILE_ELEMENT_TYPE_PATH && !tile_element_is_ghost(tileElement)) {
                     continue;
                 }
-                footpathElement = mapElement;
+                footpathElement = tileElement;
                 break;
             }
         } else {
-            footpathElement = mapElement;
+            footpathElement = tileElement;
         }
 
         if (footpathElement != NULL) {
@@ -543,7 +543,7 @@ void game_command_place_footpath(sint32 *eax, sint32 *ebx, sint32 *ecx, sint32 *
 
 static money32 footpath_place_from_track(sint32 type, sint32 x, sint32 y, sint32 z, sint32 slope, sint32 edges, sint32 flags)
 {
-    rct_tile_element * mapElement, * entranceElement;
+    rct_tile_element * tileElement, * entranceElement;
     bool entrancePath = false, entranceIsSamePath = false;
 
     gCommandExpenditureType = RCT_EXPENDITURE_TYPE_LANDSCAPING;
@@ -614,9 +614,9 @@ static money32 footpath_place_from_track(sint32 type, sint32 x, sint32 y, sint32
         return MONEY32_UNDEFINED;
     }
 
-    mapElement = map_get_surface_element_at((x / 32), (y / 32));
+    tileElement = map_get_surface_element_at((x / 32), (y / 32));
 
-    sint32 supportHeight = z - mapElement->base_height;
+    sint32 supportHeight = z - tileElement->base_height;
     gFootpathPrice += supportHeight < 0 ? MONEY(20, 00) : (supportHeight / 2) * MONEY(5, 00);
 
     if (flags & GAME_COMMAND_FLAG_APPLY) {
@@ -639,18 +639,18 @@ static money32 footpath_place_from_track(sint32 type, sint32 x, sint32 y, sint32
         }
         else
         {
-            mapElement = tile_element_insert(x / 32, y / 32, z, 0x0F);
-            assert(mapElement != NULL);
-            mapElement->type = TILE_ELEMENT_TYPE_PATH;
-            mapElement->clearance_height = z + 4 + ((slope & 4) ? 2 : 0);
-            mapElement->properties.path.type = (type << 4) | (slope & 7);
-            mapElement->type |= type >> 7;
-            mapElement->properties.path.additions = 0;
-            mapElement->properties.path.addition_status = 255;
-            mapElement->properties.path.edges = edges & 0xF;
-            mapElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
+            tileElement = tile_element_insert(x / 32, y / 32, z, 0x0F);
+            assert(tileElement != NULL);
+            tileElement->type = TILE_ELEMENT_TYPE_PATH;
+            tileElement->clearance_height = z + 4 + ((slope & 4) ? 2 : 0);
+            tileElement->properties.path.type = (type << 4) | (slope & 7);
+            tileElement->type |= type >> 7;
+            tileElement->properties.path.additions = 0;
+            tileElement->properties.path.addition_status = 255;
+            tileElement->properties.path.edges = edges & 0xF;
+            tileElement->flags &= ~TILE_ELEMENT_FLAG_BROKEN;
             if (flags & (1 << 6))
-                mapElement->flags |= TILE_ELEMENT_FLAG_GHOST;
+                tileElement->flags |= TILE_ELEMENT_FLAG_GHOST;
 
             map_invalidate_tile_full(x, y);
         }
@@ -780,18 +780,18 @@ void footpath_provisional_update()
  *      x: ax
  *      y: bx
  *      direction: ecx
- *      mapElement: edx
+ *      tileElement: edx
  */
-void footpath_get_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 *x, sint32 *y, sint32 *direction, rct_tile_element **mapElement)
+void footpath_get_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 *x, sint32 *y, sint32 *direction, rct_tile_element **tileElement)
 {
     sint32 z = 0, interactionType;
-    rct_tile_element *myMapElement;
+    rct_tile_element *myTileElement;
     rct_viewport *viewport;
     LocationXY16 position = { 0 };
 
-    get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_FOOTPATH, &position.x, &position.y, &interactionType, &myMapElement, &viewport);
+    get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_FOOTPATH, &position.x, &position.y, &interactionType, &myTileElement, &viewport);
     if (interactionType != VIEWPORT_INTERACTION_ITEM_FOOTPATH || !(viewport->flags & (VIEWPORT_FLAG_UNDERGROUND_INSIDE | VIEWPORT_FLAG_HIDE_BASE | VIEWPORT_FLAG_HIDE_VERTICAL))) {
-        get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_FOOTPATH & VIEWPORT_INTERACTION_MASK_TERRAIN, &position.x, &position.y, &interactionType, &myMapElement, &viewport);
+        get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_FOOTPATH & VIEWPORT_INTERACTION_MASK_TERRAIN, &position.x, &position.y, &interactionType, &myTileElement, &viewport);
         if (interactionType == VIEWPORT_INTERACTION_ITEM_NONE) {
             if (x != NULL) *x = LOCATION_NULL;
             return;
@@ -805,8 +805,8 @@ void footpath_get_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 *x
     position.y += 16;
 
     if (interactionType == VIEWPORT_INTERACTION_ITEM_FOOTPATH) {
-        z = myMapElement->base_height * 8;
-        if (myMapElement->properties.path.type & (1 << 2)) {
+        z = myTileElement->base_height * 8;
+        if (myTileElement->properties.path.type & (1 << 2)) {
             z += 8;
         }
     }
@@ -842,7 +842,7 @@ void footpath_get_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 *x
     if (x != NULL) *x = position.x & ~0x1F;
     if (y != NULL) *y = position.y & ~0x1F;
     if (direction != NULL) *direction = myDirection;
-    if (mapElement != NULL) *mapElement = myMapElement;
+    if (tileElement != NULL) *tileElement = myTileElement;
 }
 
 /**
@@ -853,47 +853,47 @@ void footpath_get_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 *x
  * x: ax
  * y: bx
  * direction: cl
- * mapElement: edx
+ * tileElement: edx
  */
-void footpath_bridge_get_info_from_pos(sint32 screenX, sint32 screenY, sint32 *x, sint32 *y, sint32 *direction, rct_tile_element **mapElement)
+void footpath_bridge_get_info_from_pos(sint32 screenX, sint32 screenY, sint32 *x, sint32 *y, sint32 *direction, rct_tile_element **tileElement)
 {
     // First check if we point at an entrance or exit. In that case, we would want the path coming from the entrance/exit.
     sint32 interactionType;
     rct_viewport *viewport;
 
     LocationXY16 map_pos = { 0 };
-    get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_RIDE, &map_pos.x, &map_pos.y, &interactionType, mapElement, &viewport);
+    get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_RIDE, &map_pos.x, &map_pos.y, &interactionType, tileElement, &viewport);
     *x = map_pos.x;
     *y = map_pos.y;
 
     if (interactionType == VIEWPORT_INTERACTION_ITEM_RIDE
         && viewport->flags & (VIEWPORT_FLAG_UNDERGROUND_INSIDE | VIEWPORT_FLAG_HIDE_BASE | VIEWPORT_FLAG_HIDE_VERTICAL)
-        && tile_element_get_type(*mapElement) == TILE_ELEMENT_TYPE_ENTRANCE
+        && tile_element_get_type(*tileElement) == TILE_ELEMENT_TYPE_ENTRANCE
     ) {
-        sint32 directions = entrance_get_directions(*mapElement);
+        sint32 directions = entrance_get_directions(*tileElement);
         if (directions & 0x0F) {
             sint32 bx = bitscanforward(directions);
-            bx += (*mapElement)->type;
+            bx += (*tileElement)->type;
             bx &= 3;
             if (direction != NULL) *direction = bx;
             return;
         }
     }
 
-    get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_RIDE & VIEWPORT_INTERACTION_MASK_FOOTPATH & VIEWPORT_INTERACTION_MASK_TERRAIN, &map_pos.x, &map_pos.y, &interactionType, mapElement, &viewport);
+    get_map_coordinates_from_pos(screenX, screenY, VIEWPORT_INTERACTION_MASK_RIDE & VIEWPORT_INTERACTION_MASK_FOOTPATH & VIEWPORT_INTERACTION_MASK_TERRAIN, &map_pos.x, &map_pos.y, &interactionType, tileElement, &viewport);
     *x = map_pos.x;
     *y = map_pos.y;
-    if (interactionType == VIEWPORT_INTERACTION_ITEM_RIDE && tile_element_get_type(*mapElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
-        sint32 directions = entrance_get_directions(*mapElement);
+    if (interactionType == VIEWPORT_INTERACTION_ITEM_RIDE && tile_element_get_type(*tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+        sint32 directions = entrance_get_directions(*tileElement);
         if (directions & 0x0F) {
-            sint32 bx = tile_element_get_direction_with_offset(*mapElement, bitscanforward(directions));
+            sint32 bx = tile_element_get_direction_with_offset(*tileElement, bitscanforward(directions));
             if (direction != NULL) *direction = bx;
             return;
         }
     }
 
     // We point at something else
-    footpath_get_coordinates_from_pos(screenX, screenY, x, y, direction, mapElement);
+    footpath_get_coordinates_from_pos(screenX, screenY, x, y, direction, tileElement);
 }
 
 /**
@@ -950,25 +950,25 @@ void footpath_interrupt_peeps(sint32 x, sint32 y, sint32 z)
  */
 bool fence_in_the_way(sint32 x, sint32 y, sint32 z0, sint32 z1, sint32 direction)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
-    if (mapElement == NULL)
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
+    if (tileElement == NULL)
         return false;
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
             continue;
-        if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
-        if (z0 >= mapElement->clearance_height)
+        if (z0 >= tileElement->clearance_height)
             continue;
-        if (z1 <= mapElement->base_height)
+        if (z1 <= tileElement->base_height)
             continue;
-        if ((tile_element_get_direction(mapElement)) != direction)
+        if ((tile_element_get_direction(tileElement)) != direction)
             continue;
 
         return true;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return false;
 }
 
@@ -984,19 +984,19 @@ static bool map_is_edge(sint32 x, sint32 y)
 
 static rct_tile_element *footpath_connect_corners_get_neighbour(sint32 x, sint32 y, sint32 z, sint32 requireEdges)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
-        if (footpath_element_is_queue(mapElement))
+        if (footpath_element_is_queue(tileElement))
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
-        if (!(mapElement->properties.path.edges & requireEdges))
+        if (!(tileElement->properties.path.edges & requireEdges))
             continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return NULL;
 }
 
@@ -1008,17 +1008,17 @@ static rct_tile_element *footpath_connect_corners_get_neighbour(sint32 x, sint32
  *
  *  rct2: 0x006A70EB
  */
-static void footpath_connect_corners(sint32 initialX, sint32 initialY, rct_tile_element *initialMapElement)
+static void footpath_connect_corners(sint32 initialX, sint32 initialY, rct_tile_element *initialTileElement)
 {
-    rct_tile_element *mapElement[4];
+    rct_tile_element *tileElement[4];
 
-    if (footpath_element_is_queue(initialMapElement))
+    if (footpath_element_is_queue(initialTileElement))
         return;
-    if (footpath_element_is_sloped(initialMapElement))
+    if (footpath_element_is_sloped(initialTileElement))
         return;
 
-    mapElement[0] = initialMapElement;
-    sint32 z = initialMapElement->base_height;
+    tileElement[0] = initialTileElement;
+    sint32 z = initialTileElement->base_height;
     for (sint32 initialDirection = 0; initialDirection < 4; initialDirection++) {
         sint32 x = initialX;
         sint32 y = initialY;
@@ -1026,44 +1026,44 @@ static void footpath_connect_corners(sint32 initialX, sint32 initialY, rct_tile_
 
         x += TileDirectionDelta[direction].x;
         y += TileDirectionDelta[direction].y;
-        mapElement[1] = footpath_connect_corners_get_neighbour(x, y, z, (1 << (direction ^ 2)));
-        if (mapElement[1] == NULL)
+        tileElement[1] = footpath_connect_corners_get_neighbour(x, y, z, (1 << (direction ^ 2)));
+        if (tileElement[1] == NULL)
             continue;
 
         direction = (direction + 1) & 3;
         x += TileDirectionDelta[direction].x;
         y += TileDirectionDelta[direction].y;
-        mapElement[2] = footpath_connect_corners_get_neighbour(x, y, z, (1 << (direction ^ 2)));
-        if (mapElement[2] == NULL)
+        tileElement[2] = footpath_connect_corners_get_neighbour(x, y, z, (1 << (direction ^ 2)));
+        if (tileElement[2] == NULL)
             continue;
 
         direction = (direction + 1) & 3;
         x += TileDirectionDelta[direction].x;
         y += TileDirectionDelta[direction].y;
         // First check link to previous tile
-        mapElement[3] = footpath_connect_corners_get_neighbour(x, y, z, (1 << (direction ^ 2)));
-        if (mapElement[3] == NULL)
+        tileElement[3] = footpath_connect_corners_get_neighbour(x, y, z, (1 << (direction ^ 2)));
+        if (tileElement[3] == NULL)
             continue;
         // Second check link to initial tile
-        mapElement[3] = footpath_connect_corners_get_neighbour(x, y, z, (1 << ((direction + 1) & 3)));
-        if (mapElement[3] == NULL)
+        tileElement[3] = footpath_connect_corners_get_neighbour(x, y, z, (1 << ((direction + 1) & 3)));
+        if (tileElement[3] == NULL)
             continue;
 
         direction = (direction + 1) & 3;
-        mapElement[3]->properties.path.edges |= (1 << (direction + 4));
-        map_invalidate_element(x, y, mapElement[3]);
+        tileElement[3]->properties.path.edges |= (1 << (direction + 4));
+        map_invalidate_element(x, y, tileElement[3]);
 
         direction = (direction - 1) & 3;
-        mapElement[2]->properties.path.edges |= (1 << (direction + 4));
-        map_invalidate_element(x, y, mapElement[2]);
+        tileElement[2]->properties.path.edges |= (1 << (direction + 4));
+        map_invalidate_element(x, y, tileElement[2]);
 
         direction = (direction - 1) & 3;
-        mapElement[1]->properties.path.edges |= (1 << (direction + 4));
-        map_invalidate_element(x, y, mapElement[1]);
+        tileElement[1]->properties.path.edges |= (1 << (direction + 4));
+        map_invalidate_element(x, y, tileElement[1]);
 
         direction = initialDirection;
-        mapElement[0]->properties.path.edges |= (1 << (direction + 4));
-        map_invalidate_element(x, y, mapElement[0]);
+        tileElement[0]->properties.path.edges |= (1 << (direction + 4));
+        map_invalidate_element(x, y, tileElement[0]);
     }
 }
 
@@ -1136,56 +1136,56 @@ static void neighbour_list_sort(rct_neighbour_list *neighbourList)
 
 static rct_tile_element *footpath_get_element(sint32 x, sint32 y, sint32 z0, sint32 z1, sint32 direction)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     sint32 slope;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        if (z1 == mapElement->base_height) {
-            if (footpath_element_is_sloped(mapElement)) {
-                slope = footpath_element_get_slope_direction(mapElement);
+        if (z1 == tileElement->base_height) {
+            if (footpath_element_is_sloped(tileElement)) {
+                slope = footpath_element_get_slope_direction(tileElement);
                 if (slope != direction)
                     break;
             }
-            return mapElement;
+            return tileElement;
         }
-        if (z0 == mapElement->base_height) {
-            if (!footpath_element_is_sloped(mapElement))
+        if (z0 == tileElement->base_height) {
+            if (!footpath_element_is_sloped(tileElement))
                 break;
 
-            slope = footpath_element_get_slope_direction(mapElement) ^ 2;
+            slope = footpath_element_get_slope_direction(tileElement) ^ 2;
             if (slope != direction)
                 break;
 
-            return mapElement;
+            return tileElement;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return NULL;
 }
 
-static bool sub_footpath_disconnect_queue_from_path(sint32 x, sint32 y, rct_tile_element *mapElement, sint32 action, sint32 direction) {
-    if (((mapElement->properties.path.edges & (1 << direction)) == 0) ^ (action < 0))
+static bool sub_footpath_disconnect_queue_from_path(sint32 x, sint32 y, rct_tile_element *tileElement, sint32 action, sint32 direction) {
+    if (((tileElement->properties.path.edges & (1 << direction)) == 0) ^ (action < 0))
         return false;
-    if ((action < 0) && fence_in_the_way(x, y, mapElement->base_height, mapElement->clearance_height, direction))
+    if ((action < 0) && fence_in_the_way(x, y, tileElement->base_height, tileElement->clearance_height, direction))
         return false;
 
     sint32 x1 = x + TileDirectionDelta[direction].x;
     sint32 y1 = y + TileDirectionDelta[direction].y;
-    sint32 z = mapElement->base_height;
-    rct_tile_element *otherMapElement = footpath_get_element(x1, y1, z - 2, z, direction);
-    if (otherMapElement != NULL && !footpath_element_is_queue(otherMapElement)) {
-        mapElement->properties.path.type &= 0xFC;
+    sint32 z = tileElement->base_height;
+    rct_tile_element *otherTileElement = footpath_get_element(x1, y1, z - 2, z, direction);
+    if (otherTileElement != NULL && !footpath_element_is_queue(otherTileElement)) {
+        tileElement->properties.path.type &= 0xFC;
         if (action > 0) {
-            mapElement->properties.path.edges &= ~(1 << direction);
-            otherMapElement->properties.path.edges &= ~(1 << ((direction + 2) & 3));
-            if (action >= 2) mapElement->properties.path.type |= direction;
+            tileElement->properties.path.edges &= ~(1 << direction);
+            otherTileElement->properties.path.edges &= ~(1 << ((direction + 2) & 3));
+            if (action >= 2) tileElement->properties.path.type |= direction;
         }
         else if (action < 0) {
-            mapElement->properties.path.edges |= (1 << direction);
-            otherMapElement->properties.path.edges |= (1 << ((direction + 2) & 3));
+            tileElement->properties.path.edges |= (1 << direction);
+            otherTileElement->properties.path.edges |= (1 << ((direction + 2) & 3));
         }
         if (action != 0) map_invalidate_tile_full(x1, y1);
         return true;
@@ -1193,39 +1193,39 @@ static bool sub_footpath_disconnect_queue_from_path(sint32 x, sint32 y, rct_tile
     return false;
 }
 
-static bool footpath_disconnect_queue_from_path(sint32 x, sint32 y, rct_tile_element *mapElement, sint32 action) {
-    if (!footpath_element_is_queue(mapElement)) return false;
+static bool footpath_disconnect_queue_from_path(sint32 x, sint32 y, rct_tile_element *tileElement, sint32 action) {
+    if (!footpath_element_is_queue(tileElement)) return false;
 
-    if (footpath_element_is_sloped(mapElement)) return false;
+    if (footpath_element_is_sloped(tileElement)) return false;
 
-    uint8 c = connected_path_count[mapElement->properties.path.edges & 0x0F];
+    uint8 c = connected_path_count[tileElement->properties.path.edges & 0x0F];
     if ((action < 0) ? (c >= 2) : (c < 2)) return false;
 
     if (action < 0) {
-        if (sub_footpath_disconnect_queue_from_path(x, y, mapElement, action, mapElement->properties.path.type & 3))
+        if (sub_footpath_disconnect_queue_from_path(x, y, tileElement, action, tileElement->properties.path.type & 3))
             return true;
     }
 
     for (sint32 direction = 0; direction < 4; direction++) {
-        if ((action < 0) && (direction == (mapElement->properties.path.type & 3))) continue;
-        if (sub_footpath_disconnect_queue_from_path(x, y, mapElement, action, direction))
+        if ((action < 0) && (direction == (tileElement->properties.path.type & 3))) continue;
+        if (sub_footpath_disconnect_queue_from_path(x, y, tileElement, action, direction))
             return true;
     }
 
     return false;
 }
 
-static bool footpath_is_queue_connected_to_path(sint32 x, sint32 y, rct_tile_element *mapElement, sint32 direction)
+static bool footpath_is_queue_connected_to_path(sint32 x, sint32 y, rct_tile_element *tileElement, sint32 direction)
 {
-    if (!footpath_element_is_queue(mapElement)) return false;
-    if (!(mapElement->properties.path.edges & (1 << direction))) return false;
+    if (!footpath_element_is_queue(tileElement)) return false;
+    if (!(tileElement->properties.path.edges & (1 << direction))) return false;
 
     x += TileDirectionDelta[direction].x;
     y += TileDirectionDelta[direction].y;
-    mapElement = map_get_path_element_at(x / 32, y / 32, mapElement->base_height);
-    if (mapElement == NULL) return false;
-    if (footpath_element_is_queue(mapElement)) return false;
-    if (mapElement->properties.path.edges & ((1 << direction) ^ 2)) return true;
+    tileElement = map_get_path_element_at(x / 32, y / 32, tileElement->base_height);
+    if (tileElement == NULL) return false;
+    if (footpath_element_is_queue(tileElement)) return false;
+    if (tileElement->properties.path.edges & ((1 << direction) ^ 2)) return true;
     return false;
 }
 
@@ -1234,7 +1234,7 @@ static bool footpath_is_queue_connected_to_path(sint32 x, sint32 y, rct_tile_ele
  *  rct2: 0x006A6D7E
  */
 static void loc_6A6D7E(
-    sint32 initialX, sint32 initialY, sint32 z, sint32 direction, rct_tile_element *initialMapElement,
+    sint32 initialX, sint32 initialY, sint32 z, sint32 direction, rct_tile_element *initialTileElement,
     sint32 flags, bool query, rct_neighbour_list *neighbourList
 ) {
     sint32 x = initialX + TileDirectionDelta[direction].x;
@@ -1244,54 +1244,54 @@ static void loc_6A6D7E(
             neighbour_list_push(neighbourList, 7, direction, 255, 255);
         }
     } else {
-        rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do {
-            switch (tile_element_get_type(mapElement)) {
+            switch (tile_element_get_type(tileElement)) {
             case TILE_ELEMENT_TYPE_PATH:
-                if (z == mapElement->base_height) {
-                    if (footpath_element_is_sloped(mapElement) && footpath_element_get_slope_direction(mapElement) != direction) {
+                if (z == tileElement->base_height) {
+                    if (footpath_element_is_sloped(tileElement) && footpath_element_get_slope_direction(tileElement) != direction) {
                         return;
                     } else {
                         goto loc_6A6F1F;
                     }
                 }
-                if (z - 2 == mapElement->base_height) {
-                    if (!footpath_element_is_sloped(mapElement) || footpath_element_get_slope_direction(mapElement) != (direction ^ 2)) {
+                if (z - 2 == tileElement->base_height) {
+                    if (!footpath_element_is_sloped(tileElement) || footpath_element_get_slope_direction(tileElement) != (direction ^ 2)) {
                         return;
                     }
                     goto loc_6A6F1F;
                 }
                 break;
             case TILE_ELEMENT_TYPE_TRACK:
-                if (z == mapElement->base_height) {
-                    Ride *ride = get_ride(mapElement->properties.track.ride_index);
+                if (z == tileElement->base_height) {
+                    Ride *ride = get_ride(tileElement->properties.track.ride_index);
                     if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
                         continue;
                     }
 
-                    const uint8 trackType = mapElement->properties.track.type;
-                    const uint8 trackSequence = tile_element_get_track_sequence(mapElement);
+                    const uint8 trackType = tileElement->properties.track.type;
+                    const uint8 trackSequence = tile_element_get_track_sequence(tileElement);
                     if (!(FlatRideTrackSequenceProperties[trackType][trackSequence] & TRACK_SEQUENCE_FLAG_CONNECTS_TO_PATH)) {
                         return;
                     }
-                    uint16 dx = (direction - tile_element_get_direction(mapElement)) ^ 2;
+                    uint16 dx = (direction - tile_element_get_direction(tileElement)) ^ 2;
                     if (!(FlatRideTrackSequenceProperties[trackType][trackSequence] & (1 << dx))) {
                         return;
                     }
                     if (query) {
-                        neighbour_list_push(neighbourList, 1, direction, mapElement->properties.track.ride_index, 255);
+                        neighbour_list_push(neighbourList, 1, direction, tileElement->properties.track.ride_index, 255);
                     }
                     goto loc_6A6FD2;
                 }
                 break;
             case TILE_ELEMENT_TYPE_ENTRANCE:
-                if (z == mapElement->base_height) {
-                    if (entrance_has_direction(mapElement, ((direction - tile_element_get_direction(mapElement)) & TILE_ELEMENT_DIRECTION_MASK) ^ 2)) {
+                if (z == tileElement->base_height) {
+                    if (entrance_has_direction(tileElement, ((direction - tile_element_get_direction(tileElement)) & TILE_ELEMENT_DIRECTION_MASK) ^ 2)) {
                         if (query) {
-                            neighbour_list_push(neighbourList, 8, direction, mapElement->properties.entrance.ride_index,  mapElement->properties.entrance.index);
+                            neighbour_list_push(neighbourList, 8, direction, tileElement->properties.entrance.ride_index,  tileElement->properties.entrance.index);
                         } else {
-                            if (mapElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE) {
-                                footpath_queue_chain_push(mapElement->properties.entrance.ride_index);
+                            if (tileElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE) {
+                                footpath_queue_chain_push(tileElement->properties.entrance.ride_index);
                             }
                         }
                         goto loc_6A6FD2;
@@ -1299,22 +1299,22 @@ static void loc_6A6D7E(
                 }
                 break;
             }
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
         return;
 
     loc_6A6F1F:
         if (query) {
-            if (fence_in_the_way(x, y, mapElement->base_height, mapElement->clearance_height, direction ^ 2)) {
+            if (fence_in_the_way(x, y, tileElement->base_height, tileElement->clearance_height, direction ^ 2)) {
                 return;
             }
-            if (footpath_element_is_queue(mapElement)) {
-                if (connected_path_count[mapElement->properties.path.edges & 0x0F] < 2) {
-                    neighbour_list_push(neighbourList, 4, direction, mapElement->properties.path.ride_index, mapElement->properties.entrance.index);
+            if (footpath_element_is_queue(tileElement)) {
+                if (connected_path_count[tileElement->properties.path.edges & 0x0F] < 2) {
+                    neighbour_list_push(neighbourList, 4, direction, tileElement->properties.path.ride_index, tileElement->properties.entrance.index);
                 } else {
-                    if (tile_element_get_type(initialMapElement) == TILE_ELEMENT_TYPE_PATH &&
-                        footpath_element_is_queue(initialMapElement)) {
-                        if (footpath_disconnect_queue_from_path(x, y, mapElement, 0)) {
-                            neighbour_list_push(neighbourList, 3, direction, mapElement->properties.path.ride_index, mapElement->properties.entrance.index);
+                    if (tile_element_get_type(initialTileElement) == TILE_ELEMENT_TYPE_PATH &&
+                        footpath_element_is_queue(initialTileElement)) {
+                        if (footpath_disconnect_queue_from_path(x, y, tileElement, 0)) {
+                            neighbour_list_push(neighbourList, 3, direction, tileElement->properties.path.ride_index, tileElement->properties.entrance.index);
                         }
                     }
                 }
@@ -1322,76 +1322,76 @@ static void loc_6A6D7E(
                 neighbour_list_push(neighbourList, 2, direction, 255, 255);
             }
         } else {
-            footpath_disconnect_queue_from_path(x, y, mapElement, 1 + ((flags >> 6) & 1));
-            mapElement->properties.path.edges |= (1 << (direction ^ 2));
-            if (footpath_element_is_queue(mapElement)) {
-                footpath_queue_chain_push(mapElement->properties.path.ride_index);
+            footpath_disconnect_queue_from_path(x, y, tileElement, 1 + ((flags >> 6) & 1));
+            tileElement->properties.path.edges |= (1 << (direction ^ 2));
+            if (footpath_element_is_queue(tileElement)) {
+                footpath_queue_chain_push(tileElement->properties.path.ride_index);
             }
         }
         if (!(flags & (GAME_COMMAND_FLAG_GHOST | GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED))) {
-            footpath_interrupt_peeps(x, y, mapElement->base_height * 8);
+            footpath_interrupt_peeps(x, y, tileElement->base_height * 8);
         }
-        map_invalidate_element(x, y, mapElement);
+        map_invalidate_element(x, y, tileElement);
     }
 
 loc_6A6FD2:
-    if (tile_element_get_type(initialMapElement) == TILE_ELEMENT_TYPE_PATH) {
+    if (tile_element_get_type(initialTileElement) == TILE_ELEMENT_TYPE_PATH) {
         if (!query) {
-            initialMapElement->properties.path.edges |= (1 << direction);
-            map_invalidate_element(initialX, initialY, initialMapElement);
+            initialTileElement->properties.path.edges |= (1 << direction);
+            map_invalidate_element(initialX, initialY, initialTileElement);
         }
     }
 }
 
 static void loc_6A6C85(
-    sint32 x, sint32 y, sint32 direction, rct_tile_element *mapElement,
+    sint32 x, sint32 y, sint32 direction, rct_tile_element *tileElement,
     sint32 flags, bool query, rct_neighbour_list *neighbourList
 ) {
-    if (query && fence_in_the_way(x, y, mapElement->base_height, mapElement->clearance_height, direction))
+    if (query && fence_in_the_way(x, y, tileElement->base_height, tileElement->clearance_height, direction))
         return;
 
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
-        if (!entrance_has_direction(mapElement, (direction - mapElement->type) & 3)) {
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+        if (!entrance_has_direction(tileElement, (direction - tileElement->type) & 3)) {
             return;
         }
     }
 
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK) {
-        Ride *ride = get_ride(mapElement->properties.track.ride_index);
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK) {
+        Ride *ride = get_ride(tileElement->properties.track.ride_index);
         if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
             return;
         }
-        const uint8 trackType = mapElement->properties.track.type;
-        const uint8 trackSequence = tile_element_get_track_sequence(mapElement);
+        const uint8 trackType = tileElement->properties.track.type;
+        const uint8 trackSequence = tile_element_get_track_sequence(tileElement);
         if (!(FlatRideTrackSequenceProperties[trackType][trackSequence] & TRACK_SEQUENCE_FLAG_CONNECTS_TO_PATH)) {
             return;
         }
-        uint16 dx = (direction - tile_element_get_direction(mapElement)) & TILE_ELEMENT_DIRECTION_MASK;
+        uint16 dx = (direction - tile_element_get_direction(tileElement)) & TILE_ELEMENT_DIRECTION_MASK;
         if (!(FlatRideTrackSequenceProperties[trackType][trackSequence] & (1 << dx))) {
             return;
         }
     }
 
-    sint32 z = mapElement->base_height;
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH) {
-        if (footpath_element_is_sloped(mapElement)) {
-            if ((footpath_element_get_slope_direction(mapElement) - direction) & 1) {
+    sint32 z = tileElement->base_height;
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+        if (footpath_element_is_sloped(tileElement)) {
+            if ((footpath_element_get_slope_direction(tileElement) - direction) & 1) {
                 return;
             }
-            if (footpath_element_get_slope_direction(mapElement) == direction) {
+            if (footpath_element_get_slope_direction(tileElement) == direction) {
                 z += 2;
             }
         }
     }
 
-    loc_6A6D7E(x, y, z, direction, mapElement, flags, query, neighbourList);
+    loc_6A6D7E(x, y, z, direction, tileElement, flags, query, neighbourList);
 }
 
 /**
  *
  *  rct2: 0x006A6C66
  */
-void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *mapElement, sint32 flags)
+void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *tileElement, sint32 flags)
 {
     rct_neighbour_list neighbourList;
     rct_neighbour neighbour;
@@ -1400,14 +1400,14 @@ void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *mapElement, si
 
     neighbour_list_init(&neighbourList);
 
-    footpath_update_queue_entrance_banner(x, y, mapElement);
+    footpath_update_queue_entrance_banner(x, y, tileElement);
     for (sint32 direction = 0; direction < 4; direction++) {
-        loc_6A6C85(x, y, direction, mapElement, flags, true, &neighbourList);
+        loc_6A6C85(x, y, direction, tileElement, flags, true, &neighbourList);
     }
 
     neighbour_list_sort(&neighbourList);
 
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH && footpath_element_is_queue(mapElement)) {
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH && footpath_element_is_queue(tileElement)) {
         sint32 rideIndex = -1;
         uint8 entranceIndex = 255;
         for (sint32 i = 0; i < neighbourList.count; i++) {
@@ -1429,11 +1429,11 @@ void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *mapElement, si
     }
 
     while (neighbour_list_pop(&neighbourList, &neighbour)) {
-        loc_6A6C85(x, y, neighbour.direction, mapElement, flags, false, NULL);
+        loc_6A6C85(x, y, neighbour.direction, tileElement, flags, false, NULL);
     }
 
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH) {
-        footpath_connect_corners(x, y, mapElement);
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+        footpath_connect_corners(x, y, tileElement);
     }
 }
 
@@ -1441,22 +1441,22 @@ void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *mapElement, si
  *
  *  rct2: 0x006A742F
  */
-void footpath_chain_ride_queue(sint32 rideIndex, sint32 entranceIndex, sint32 x, sint32 y, rct_tile_element *mapElement, sint32 direction)
+void footpath_chain_ride_queue(sint32 rideIndex, sint32 entranceIndex, sint32 x, sint32 y, rct_tile_element *tileElement, sint32 direction)
 {
     rct_tile_element *lastPathElement, *lastQueuePathElement;
     sint32 lastPathX = x, lastPathY = y, lastPathDirection = direction;
 
     lastPathElement = NULL;
     lastQueuePathElement = NULL;
-    sint32 z = mapElement->base_height;
+    sint32 z = tileElement->base_height;
     for (;;) {
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH) {
-            lastPathElement = mapElement;
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+            lastPathElement = tileElement;
             lastPathX = x;
             lastPathY = y;
             lastPathDirection = direction;
-            if (footpath_element_is_sloped(mapElement)) {
-                if (footpath_element_get_slope_direction(mapElement) == direction) {
+            if (footpath_element_is_sloped(tileElement)) {
+                if (footpath_element_get_slope_direction(tileElement) == direction) {
                     z += 2;
                 }
             }
@@ -1464,37 +1464,37 @@ void footpath_chain_ride_queue(sint32 rideIndex, sint32 entranceIndex, sint32 x,
 
         x += TileDirectionDelta[direction].x;
         y += TileDirectionDelta[direction].y;
-        mapElement = map_get_first_element_at(x >> 5, y >> 5);
+        tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do {
-            if (lastQueuePathElement == mapElement)
+            if (lastQueuePathElement == tileElement)
                 continue;
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
                 continue;
-            if (mapElement->base_height == z) {
-                if (footpath_element_is_sloped(mapElement)) {
-                    if (footpath_element_get_slope_direction(mapElement) != direction)
+            if (tileElement->base_height == z) {
+                if (footpath_element_is_sloped(tileElement)) {
+                    if (footpath_element_get_slope_direction(tileElement) != direction)
                         break;
                 }
                 goto foundNextPath;
             }
-            if (mapElement->base_height == z - 2) {
-                if (!footpath_element_is_sloped(mapElement))
+            if (tileElement->base_height == z - 2) {
+                if (!footpath_element_is_sloped(tileElement))
                     break;
 
-                if ((footpath_element_get_slope_direction(mapElement) ^ 2) != direction)
+                if ((footpath_element_get_slope_direction(tileElement) ^ 2) != direction)
                     break;
 
                 z -= 2;
                 goto foundNextPath;
             }
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
         break;
 
     foundNextPath:
-        if (footpath_element_is_queue(mapElement)) {
+        if (footpath_element_is_queue(tileElement)) {
             // Fix #2051: Stop queue paths that are already connected to two other tiles
             //            from connecting to the tile we are coming from.
-            sint32 edges = mapElement->properties.path.edges;
+            sint32 edges = tileElement->properties.path.edges;
             sint32 numEdges = bitcount(edges);
             if (numEdges >= 2) {
                 sint32 requiredEdgeMask = 1 << (direction ^ 2);
@@ -1503,27 +1503,27 @@ void footpath_chain_ride_queue(sint32 rideIndex, sint32 entranceIndex, sint32 x,
                 }
             }
 
-            mapElement->properties.path.type &= ~(1 << 3);
-            mapElement->properties.path.edges |= (1 << (direction ^ 2));
-            mapElement->properties.path.ride_index = rideIndex;
-            mapElement->properties.path.additions &= 0x8F;
-            mapElement->properties.path.additions |= (entranceIndex & 7) << 4;
+            tileElement->properties.path.type &= ~(1 << 3);
+            tileElement->properties.path.edges |= (1 << (direction ^ 2));
+            tileElement->properties.path.ride_index = rideIndex;
+            tileElement->properties.path.additions &= 0x8F;
+            tileElement->properties.path.additions |= (entranceIndex & 7) << 4;
 
-            map_invalidate_element(x, y, mapElement);
+            map_invalidate_element(x, y, tileElement);
 
             if (lastQueuePathElement == NULL) {
-                lastQueuePathElement = mapElement;
+                lastQueuePathElement = tileElement;
             }
 
-            if (mapElement->properties.path.edges & (1 << direction))
+            if (tileElement->properties.path.edges & (1 << direction))
                 continue;
 
             direction = (direction + 1) & 3;
-            if (mapElement->properties.path.edges & (1 << direction))
+            if (tileElement->properties.path.edges & (1 << direction))
                 continue;
 
             direction ^= 2;
-            if (mapElement->properties.path.edges & (1 << direction))
+            if (tileElement->properties.path.edges & (1 << direction))
                 continue;
         }
         break;
@@ -1586,15 +1586,15 @@ void footpath_update_queue_chains()
             uint8 y = ride->entrances[i].y;
             uint8 z = ride->station_heights[i];
 
-            rct_tile_element *mapElement = map_get_first_element_at(x, y);
+            rct_tile_element *tileElement = map_get_first_element_at(x, y);
             do {
-                if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
-                if (mapElement->base_height != z) continue;
-                if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE) continue;
+                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+                if (tileElement->base_height != z) continue;
+                if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE) continue;
 
-                uint8 direction = tile_element_get_direction_with_offset(mapElement, 2);
-                footpath_chain_ride_queue(rideIndex, i, x << 5, y << 5, mapElement, direction);
-            } while (!tile_element_is_last_for_tile(mapElement++));
+                uint8 direction = tile_element_get_direction_with_offset(tileElement, 2);
+                footpath_chain_ride_queue(rideIndex, i, x << 5, y << 5, tileElement, direction);
+            } while (!tile_element_is_last_for_tile(tileElement++));
         }
     }
 }
@@ -1656,7 +1656,7 @@ static sint32 footpath_is_connected_to_map_edge_recurse(
     sint32 x, sint32 y, sint32 z, sint32 direction, sint32 flags,
     sint32 level, sint32 distanceFromJunction, sint32 junctionTolerance
 ) {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     sint32 edges, slopeDirection;
 
     x += TileDirectionDelta[direction].x;
@@ -1670,55 +1670,55 @@ static sint32 footpath_is_connected_to_map_edge_recurse(
     if (x >= gMapSizeUnits || y >= gMapSizeUnits)
         return FOOTPATH_SEARCH_SUCCESS;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         if (
-            footpath_element_is_sloped(mapElement) &&
-            (slopeDirection = footpath_element_get_slope_direction(mapElement)) != direction
+            footpath_element_is_sloped(tileElement) &&
+            (slopeDirection = footpath_element_get_slope_direction(tileElement)) != direction
         ) {
             if ((slopeDirection ^ 2) != direction) continue;
-            if (mapElement->base_height + 2 != z) continue;
-        } else if (mapElement->base_height != z) {
+            if (tileElement->base_height + 2 != z) continue;
+        } else if (tileElement->base_height != z) {
             continue;
         }
 
         if (!(flags & (1 << 0))) {
-            if (footpath_element_is_queue(mapElement)) {
+            if (footpath_element_is_queue(tileElement)) {
                 continue;
             }
         }
 
         if (flags & (1 << 5)) {
-            footpath_fix_ownership(x, y, mapElement);
+            footpath_fix_ownership(x, y, tileElement);
         }
-        edges = mapElement->properties.path.edges & 0x0F;
+        edges = tileElement->properties.path.edges & 0x0F;
         direction ^= 2;
         if (!(flags & (1 << 7))) {
-            if (mapElement[1].type == TILE_ELEMENT_TYPE_BANNER) {
+            if (tileElement[1].type == TILE_ELEMENT_TYPE_BANNER) {
                 for (sint32 i = 1; i < 4; i++) {
-                    if (tile_element_is_last_for_tile(&mapElement[i - 1])) break;
-                    if (mapElement[i].type != TILE_ELEMENT_TYPE_BANNER) break;
-                    edges &= mapElement[i].properties.banner.flags;
+                    if (tile_element_is_last_for_tile(&tileElement[i - 1])) break;
+                    if (tileElement[i].type != TILE_ELEMENT_TYPE_BANNER) break;
+                    edges &= tileElement[i].properties.banner.flags;
                 }
             }
-            if (mapElement[2].type == TILE_ELEMENT_TYPE_BANNER && mapElement[1].type != TILE_ELEMENT_TYPE_PATH) {
+            if (tileElement[2].type == TILE_ELEMENT_TYPE_BANNER && tileElement[1].type != TILE_ELEMENT_TYPE_PATH) {
                 for (sint32 i = 1; i < 6; i++) {
-                    if (tile_element_is_last_for_tile(&mapElement[i - 1])) break;
-                    if (mapElement[i].type != TILE_ELEMENT_TYPE_BANNER) break;
-                    edges &= mapElement[i].properties.banner.flags;
+                    if (tile_element_is_last_for_tile(&tileElement[i - 1])) break;
+                    if (tileElement[i].type != TILE_ELEMENT_TYPE_BANNER) break;
+                    edges &= tileElement[i].properties.banner.flags;
                 }
             }
         }
         goto searchFromFootpath;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return level == 1 ? FOOTPATH_SEARCH_NOT_FOUND : FOOTPATH_SEARCH_INCOMPLETE;
 
 searchFromFootpath:
     // Exclude direction we came from
-    z = mapElement->base_height;
+    z = tileElement->base_height;
     edges &= ~(1 << direction);
 
     // Find next direction to go
@@ -1729,7 +1729,7 @@ searchFromFootpath:
     edges &= ~(1 << direction);
     if (edges == 0) {
         // Only possible direction to go
-        if (footpath_element_is_sloped(mapElement) && footpath_element_get_slope_direction(mapElement) == direction) {
+        if (footpath_element_is_sloped(tileElement) && footpath_element_get_slope_direction(tileElement) == direction) {
             z += 2;
         }
         return footpath_is_connected_to_map_edge_recurse(
@@ -1748,7 +1748,7 @@ searchFromFootpath:
 
         do {
             edges &= ~(1 << direction);
-            if (footpath_element_is_sloped(mapElement) && footpath_element_get_slope_direction(mapElement) == direction) {
+            if (footpath_element_is_sloped(tileElement) && footpath_element_get_slope_direction(tileElement) == direction) {
                 z += 2;
             }
             sint32 result = footpath_is_connected_to_map_edge_recurse(x, y, z, direction, flags, level, 0, junctionTolerance);
@@ -1767,63 +1767,63 @@ sint32 footpath_is_connected_to_map_edge(sint32 x, sint32 y, sint32 z, sint32 di
     return footpath_is_connected_to_map_edge_recurse(x, y, z, direction, flags, 0, 0, 16);
 }
 
-bool footpath_element_is_sloped(rct_tile_element *mapElement)
+bool footpath_element_is_sloped(rct_tile_element *tileElement)
 {
-    return mapElement->properties.path.type & 4;
+    return tileElement->properties.path.type & 4;
 }
 
-uint8 footpath_element_get_slope_direction(rct_tile_element *mapElement)
+uint8 footpath_element_get_slope_direction(rct_tile_element *tileElement)
 {
-    return mapElement->properties.path.type & 3;
+    return tileElement->properties.path.type & 3;
 }
 
-bool footpath_element_is_queue(rct_tile_element *mapElement)
+bool footpath_element_is_queue(rct_tile_element *tileElement)
 {
-    return mapElement->type & 1;
+    return tileElement->type & 1;
 }
 
-bool footpath_element_is_wide(rct_tile_element *mapElement)
+bool footpath_element_is_wide(rct_tile_element *tileElement)
 {
-    return mapElement->type & 2;
+    return tileElement->type & 2;
 }
 
-bool footpath_element_has_path_scenery(rct_tile_element *mapElement)
+bool footpath_element_has_path_scenery(rct_tile_element *tileElement)
 {
-    return (mapElement->properties.path.additions & 0xF) > 0;
+    return (tileElement->properties.path.additions & 0xF) > 0;
 }
 
-uint8 footpath_element_get_path_scenery(rct_tile_element *mapElement)
+uint8 footpath_element_get_path_scenery(rct_tile_element *tileElement)
 {
-    return mapElement->properties.path.additions & 0xF;
+    return tileElement->properties.path.additions & 0xF;
 }
 
-void footpath_element_set_path_scenery(rct_tile_element *mapElement, uint8 pathSceneryType)
+void footpath_element_set_path_scenery(rct_tile_element *tileElement, uint8 pathSceneryType)
 {
-    mapElement->properties.path.additions = (mapElement->properties.path.additions & 0xF0) | pathSceneryType;
+    tileElement->properties.path.additions = (tileElement->properties.path.additions & 0xF0) | pathSceneryType;
 }
 
-uint8 footpath_element_get_path_scenery_index(rct_tile_element *mapElement)
+uint8 footpath_element_get_path_scenery_index(rct_tile_element *tileElement)
 {
-    return footpath_element_get_path_scenery(mapElement) - 1;
+    return footpath_element_get_path_scenery(tileElement) - 1;
 }
 
-bool footpath_element_path_scenery_is_ghost(rct_tile_element *mapElement)
+bool footpath_element_path_scenery_is_ghost(rct_tile_element *tileElement)
 {
-    return (mapElement->properties.path.additions & 0x80) == 0x80;
+    return (tileElement->properties.path.additions & 0x80) == 0x80;
 }
 
-void footpath_scenery_set_is_ghost(rct_tile_element *mapElement, bool isGhost)
+void footpath_scenery_set_is_ghost(rct_tile_element *tileElement, bool isGhost)
 {
     // Remove ghost flag
-    mapElement->properties.path.additions &= ~0x80;
+    tileElement->properties.path.additions &= ~0x80;
     // Set flag if it should be a ghost
     if (isGhost)
-        mapElement->properties.path.additions |= 0x80;
+        tileElement->properties.path.additions |= 0x80;
 }
 
-uint8 footpath_element_get_type(rct_tile_element *mapElement)
+uint8 footpath_element_get_type(rct_tile_element *tileElement)
 {
-    return mapElement->properties.path.type >> 4;
+    return tileElement->properties.path.type >> 4;
 }
 
 /**
@@ -1834,12 +1834,12 @@ uint8 footpath_element_get_type(rct_tile_element *mapElement)
 */
 static void footpath_clear_wide(sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
-        mapElement->type &= ~0x2;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        tileElement->type &= ~0x2;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 }
 
 /**
@@ -1850,18 +1850,18 @@ static void footpath_clear_wide(sint32 x, sint32 y)
 */
 static rct_tile_element* footpath_can_be_wide(sint32 x, sint32 y, uint8 height)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
-        if (height != mapElement->base_height)
+        if (height != tileElement->base_height)
             continue;
-        if (footpath_element_is_queue(mapElement))
+        if (footpath_element_is_queue(tileElement))
             continue;
-        if (footpath_element_is_sloped(mapElement))
+        if (footpath_element_is_sloped(tileElement))
             continue;
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
@@ -1901,21 +1901,21 @@ void footpath_update_path_wide_flags(sint32 x, sint32 y)
     //footpath_clear_wide(x, y);
     //y -= 0x20;
 
-    rct_tile_element *mapElement = map_get_first_element_at(x / 32, y / 32);
+    rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        if (footpath_element_is_queue(mapElement))
+        if (footpath_element_is_queue(tileElement))
             continue;
 
-        if (footpath_element_is_sloped(mapElement))
+        if (footpath_element_is_sloped(tileElement))
             continue;
 
-        if ((mapElement->properties.path.edges & 0xF) == 0)
+        if ((tileElement->properties.path.edges & 0xF) == 0)
             continue;
 
-        uint8 height = mapElement->base_height;
+        uint8 height = tileElement->base_height;
 
         // pathList is a list of elements, set by sub_6A8ACF adjacent to x,y
         // Spanned from 0x00F3EFA8 to 0x00F3EFC7 (8 elements) in the original
@@ -1941,7 +1941,7 @@ void footpath_update_path_wide_flags(sint32 x, sint32 y)
         y += 0x20;
 
         uint8 F3EFA5 = 0;
-        if (mapElement->properties.path.edges & 8) {
+        if (tileElement->properties.path.edges & 8) {
             F3EFA5 |= 0x80;
             if (pathList[7] != NULL) {
                 if (footpath_element_is_wide(pathList[7])) {
@@ -1950,7 +1950,7 @@ void footpath_update_path_wide_flags(sint32 x, sint32 y)
             }
         }
 
-        if (mapElement->properties.path.edges & 1) {
+        if (tileElement->properties.path.edges & 1) {
             F3EFA5 |= 0x2;
             if (pathList[1] != NULL) {
                 if (footpath_element_is_wide(pathList[1])) {
@@ -1959,7 +1959,7 @@ void footpath_update_path_wide_flags(sint32 x, sint32 y)
             }
         }
 
-        if (mapElement->properties.path.edges & 2) {
+        if (tileElement->properties.path.edges & 2) {
             F3EFA5 |= 0x8;
             /* In the following:
              * footpath_element_is_wide(pathList[3])
@@ -1973,7 +1973,7 @@ void footpath_update_path_wide_flags(sint32 x, sint32 y)
             //}
         }
 
-        if (mapElement->properties.path.edges & 4) {
+        if (tileElement->properties.path.edges & 4) {
             F3EFA5 |= 0x20;
             /* In the following:
              * footpath_element_is_wide(pathList[5])
@@ -2050,36 +2050,36 @@ void footpath_update_path_wide_flags(sint32 x, sint32 y)
             F3EFA5 &= ~0x20;
 
         if (!(F3EFA5 & (0x2 | 0x8 | 0x20 | 0x80))) {
-            uint8 e = mapElement->properties.path.edges;
+            uint8 e = tileElement->properties.path.edges;
             if ((e != 0xAF) && (e != 0x5F) && (e != 0xEF))
-                mapElement->type |= 2;
+                tileElement->type |= 2;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 }
 
 /**
  *
  *  rct2: 0x006A7642
  */
-void footpath_update_queue_entrance_banner(sint32 x, sint32 y, rct_tile_element *mapElement)
+void footpath_update_queue_entrance_banner(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    sint32 elementType = tile_element_get_type(mapElement);
+    sint32 elementType = tile_element_get_type(tileElement);
     switch (elementType) {
     case TILE_ELEMENT_TYPE_PATH:
-        if (footpath_element_is_queue(mapElement)) {
-            footpath_queue_chain_push(mapElement->properties.path.ride_index);
+        if (footpath_element_is_queue(tileElement)) {
+            footpath_queue_chain_push(tileElement->properties.path.ride_index);
             for (sint32 direction = 0; direction < 4; direction++) {
-                if (mapElement->properties.path.edges & (1 << direction)) {
-                    footpath_chain_ride_queue(255, 0, x, y, mapElement, direction);
+                if (tileElement->properties.path.edges & (1 << direction)) {
+                    footpath_chain_ride_queue(255, 0, x, y, tileElement, direction);
                 }
             }
-            mapElement->properties.path.ride_index = 255;
+            tileElement->properties.path.ride_index = 255;
         }
         break;
     case TILE_ELEMENT_TYPE_ENTRANCE:
-        if (mapElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
-            footpath_queue_chain_push(mapElement->properties.entrance.ride_index);
-            footpath_chain_ride_queue(255, 0, x, y, mapElement, tile_element_get_direction_with_offset(mapElement, 2));
+        if (tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
+            footpath_queue_chain_push(tileElement->properties.entrance.ride_index);
+            footpath_chain_ride_queue(255, 0, x, y, tileElement, tile_element_get_direction_with_offset(tileElement, 2));
         }
         break;
     }
@@ -2089,43 +2089,43 @@ void footpath_update_queue_entrance_banner(sint32 x, sint32 y, rct_tile_element
  *
  *  rct2: 0x006A6B7F
  */
-static void footpath_remove_edges_towards_here(sint32 x, sint32 y, sint32 z, sint32 direction, rct_tile_element *mapElement, bool isQueue)
+static void footpath_remove_edges_towards_here(sint32 x, sint32 y, sint32 z, sint32 direction, rct_tile_element *tileElement, bool isQueue)
 {
     sint32 d;
 
-    if (footpath_element_is_queue(mapElement)) {
-        footpath_queue_chain_push(mapElement->properties.path.ride_index);
+    if (footpath_element_is_queue(tileElement)) {
+        footpath_queue_chain_push(tileElement->properties.path.ride_index);
     }
 
     d = direction ^ 2;
-    mapElement->properties.path.edges &= ~(1 << d);
+    tileElement->properties.path.edges &= ~(1 << d);
     d = ((d - 1) & 3) + 4;
-    mapElement->properties.path.edges &= ~(1 << d);
+    tileElement->properties.path.edges &= ~(1 << d);
     d = (((d - 4) + 1) & 3) + 4;
-    mapElement->properties.path.edges &= ~(1 << d);
-    map_invalidate_tile(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+    tileElement->properties.path.edges &= ~(1 << d);
+    map_invalidate_tile(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
 
-    if (isQueue) footpath_disconnect_queue_from_path(x, y, mapElement, -1);
+    if (isQueue) footpath_disconnect_queue_from_path(x, y, tileElement, -1);
 
     direction = (direction + 1) & 3;
     x += TileDirectionDelta[direction].x;
     y += TileDirectionDelta[direction].y;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
 
-        if (footpath_element_is_sloped(mapElement))
+        if (footpath_element_is_sloped(tileElement))
             break;
 
         d = ((direction + 1) & 3) + 4;
-        mapElement->properties.path.edges &= ~(1 << d);
-        map_invalidate_tile(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+        tileElement->properties.path.edges &= ~(1 << d);
+        map_invalidate_tile(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
         break;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 }
 
 /**
@@ -2134,35 +2134,35 @@ static void footpath_remove_edges_towards_here(sint32 x, sint32 y, sint32 z, sin
  */
 static void footpath_remove_edges_towards(sint32 x, sint32 y, sint32 z0, sint32 z1, sint32 direction, bool isQueue)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     sint32 slope;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        if (z1 == mapElement->base_height) {
-            if (footpath_element_is_sloped(mapElement)) {
-                slope = footpath_element_get_slope_direction(mapElement);
+        if (z1 == tileElement->base_height) {
+            if (footpath_element_is_sloped(tileElement)) {
+                slope = footpath_element_get_slope_direction(tileElement);
                 if (slope != direction)
                     break;
             }
-            footpath_remove_edges_towards_here(x, y, z1, direction, mapElement, isQueue);
+            footpath_remove_edges_towards_here(x, y, z1, direction, tileElement, isQueue);
             break;
         }
-        if (z0 == mapElement->base_height) {
-            if (!footpath_element_is_sloped(mapElement))
+        if (z0 == tileElement->base_height) {
+            if (!footpath_element_is_sloped(tileElement))
                 break;
 
-            slope = footpath_element_get_slope_direction(mapElement) ^ 2;
+            slope = footpath_element_get_slope_direction(tileElement) ^ 2;
             if (slope != direction)
                 break;
 
-            footpath_remove_edges_towards_here(x, y, z1, direction, mapElement, isQueue);
+            footpath_remove_edges_towards_here(x, y, z1, direction, tileElement, isQueue);
             break;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 }
 
 /**
@@ -2171,22 +2171,22 @@ static void footpath_remove_edges_towards(sint32 x, sint32 y, sint32 z0, sint32
  * @param x x-coordinate in units (not tiles)
  * @param y y-coordinate in units (not tiles)
  */
-void footpath_remove_edges_at(sint32 x, sint32 y, rct_tile_element *mapElement)
+void footpath_remove_edges_at(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_TRACK) {
-        sint32 rideIndex = mapElement->properties.track.ride_index;
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK) {
+        sint32 rideIndex = tileElement->properties.track.ride_index;
         Ride *ride = get_ride(rideIndex);
         if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
             return;
     }
 
-    footpath_update_queue_entrance_banner(x, y, mapElement);
+    footpath_update_queue_entrance_banner(x, y, tileElement);
 
     for (sint32 direction = 0; direction < 4; direction++) {
-        sint32 z1 = mapElement->base_height;
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH) {
-            if (footpath_element_is_sloped(mapElement)) {
-                sint32 slope = footpath_element_get_slope_direction(mapElement);
+        sint32 z1 = tileElement->base_height;
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+            if (footpath_element_is_sloped(tileElement)) {
+                sint32 slope = footpath_element_get_slope_direction(tileElement);
                 if ((slope - direction) & 1)
                     continue;
 
@@ -2195,11 +2195,11 @@ void footpath_remove_edges_at(sint32 x, sint32 y, rct_tile_element *mapElement)
         }
         sint32 z0 = z1 - 2;
         footpath_remove_edges_towards(x + TileDirectionDelta[direction].x, y + TileDirectionDelta[direction].y,
-            z0, z1, direction, footpath_element_is_queue(mapElement));
+            z0, z1, direction, footpath_element_is_queue(tileElement));
     }
 
-    if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH)
-        mapElement->properties.path.edges = 0;
+    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
+        tileElement->properties.path.edges = 0;
 }
 
 rct_footpath_entry *get_footpath_entry(sint32 entryIndex)
diff --git a/src/openrct2/world/footpath.h b/src/openrct2/world/footpath.h
index d9e0136a2c..dbeaf81727 100644
--- a/src/openrct2/world/footpath.h
+++ b/src/openrct2/world/footpath.h
@@ -93,29 +93,29 @@ void footpath_remove(sint32 x, sint32 y, sint32 z, sint32 flags);
 money32 footpath_provisional_set(sint32 type, sint32 x, sint32 y, sint32 z, sint32 slope);
 void footpath_provisional_remove();
 void footpath_provisional_update();
-void footpath_get_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 *x, sint32 *y, sint32 *direction, rct_tile_element **mapElement);
-void footpath_bridge_get_info_from_pos(sint32 screenX, sint32 screenY, sint32 *x, sint32 *y, sint32 *direction, rct_tile_element **mapElement);
+void footpath_get_coordinates_from_pos(sint32 screenX, sint32 screenY, sint32 *x, sint32 *y, sint32 *direction, rct_tile_element **tileElement);
+void footpath_bridge_get_info_from_pos(sint32 screenX, sint32 screenY, sint32 *x, sint32 *y, sint32 *direction, rct_tile_element **tileElement);
 void footpath_remove_litter(sint32 x, sint32 y, sint32 z);
-void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *mapElement, sint32 flags);
+void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *tileElement, sint32 flags);
 void footpath_update_queue_chains();
 bool fence_in_the_way(sint32 x, sint32 y, sint32 z0, sint32 z1, sint32 direction);
-void footpath_chain_ride_queue(sint32 rideIndex, sint32 entranceIndex, sint32 x, sint32 y, rct_tile_element *mapElement, sint32 direction);
+void footpath_chain_ride_queue(sint32 rideIndex, sint32 entranceIndex, sint32 x, sint32 y, rct_tile_element *tileElement, sint32 direction);
 void footpath_update_path_wide_flags(sint32 x, sint32 y);
 
 sint32 footpath_is_connected_to_map_edge(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 flags);
-bool footpath_element_is_sloped(rct_tile_element *mapElement);
-uint8 footpath_element_get_slope_direction(rct_tile_element *mapElement);
-bool footpath_element_is_queue(rct_tile_element *mapElement);
-bool footpath_element_is_wide(rct_tile_element *mapElement);
-uint8 footpath_element_get_type(rct_tile_element *mapElement);
-bool footpath_element_has_path_scenery(rct_tile_element *mapElement);
-uint8 footpath_element_get_path_scenery(rct_tile_element *mapElement);
-void footpath_element_set_path_scenery(rct_tile_element *mapElement, uint8 pathSceneryType);
-uint8 footpath_element_get_path_scenery_index(rct_tile_element *mapElement);
-bool footpath_element_path_scenery_is_ghost(rct_tile_element *mapElement);
-void footpath_scenery_set_is_ghost(rct_tile_element *mapElement, bool isGhost);
-void footpath_remove_edges_at(sint32 x, sint32 y, rct_tile_element *mapElement);
-sint32 entrance_get_directions(rct_tile_element *mapElement);
+bool footpath_element_is_sloped(rct_tile_element *tileElement);
+uint8 footpath_element_get_slope_direction(rct_tile_element *tileElement);
+bool footpath_element_is_queue(rct_tile_element *tileElement);
+bool footpath_element_is_wide(rct_tile_element *tileElement);
+uint8 footpath_element_get_type(rct_tile_element *tileElement);
+bool footpath_element_has_path_scenery(rct_tile_element *tileElement);
+uint8 footpath_element_get_path_scenery(rct_tile_element *tileElement);
+void footpath_element_set_path_scenery(rct_tile_element *tileElement, uint8 pathSceneryType);
+uint8 footpath_element_get_path_scenery_index(rct_tile_element *tileElement);
+bool footpath_element_path_scenery_is_ghost(rct_tile_element *tileElement);
+void footpath_scenery_set_is_ghost(rct_tile_element *tileElement, bool isGhost);
+void footpath_remove_edges_at(sint32 x, sint32 y, rct_tile_element *tileElement);
+sint32 entrance_get_directions(rct_tile_element *tileElement);
 
 rct_footpath_entry *get_footpath_entry(sint32 entryIndex);
 
diff --git a/src/openrct2/world/map.c b/src/openrct2/world/map.c
index 6fc71d8dfe..41a6ca16b4 100644
--- a/src/openrct2/world/map.c
+++ b/src/openrct2/world/map.c
@@ -94,17 +94,17 @@ sint16 gMapSizeMaxXY;
 sint16 gMapBaseZ;
 
 #if defined(NO_RCT2)
-rct_tile_element gMapElements[MAX_TILE_TILE_ELEMENT_POINTERS * 3];
-rct_tile_element *gMapElementTilePointers[MAX_TILE_TILE_ELEMENT_POINTERS];
+rct_tile_element gTileElements[MAX_TILE_TILE_ELEMENT_POINTERS * 3];
+rct_tile_element *gTileElementTilePointers[MAX_TILE_TILE_ELEMENT_POINTERS];
 #else
-rct_tile_element *gMapElements = RCT2_ADDRESS(RCT2_ADDRESS_TILE_ELEMENTS, rct_tile_element);
-rct_tile_element **gMapElementTilePointers = RCT2_ADDRESS(RCT2_ADDRESS_TILE_TILE_ELEMENT_POINTERS, rct_tile_element*);
+rct_tile_element *gTileElements = RCT2_ADDRESS(RCT2_ADDRESS_TILE_ELEMENTS, rct_tile_element);
+rct_tile_element **gTileElementTilePointers = RCT2_ADDRESS(RCT2_ADDRESS_TILE_TILE_ELEMENT_POINTERS, rct_tile_element*);
 #endif
 LocationXY16 gMapSelectionTiles[300];
 rct2_peep_spawn gPeepSpawns[MAX_PEEP_SPAWNS];
 
-rct_tile_element *gNextFreeMapElement;
-uint32 gNextFreeMapElementPointerIndex;
+rct_tile_element *gNextFreeTileElement;
+uint32 gNextFreeTileElementPointerIndex;
 
 bool gLandMountainMode;
 bool gLandPaintMode;
@@ -119,8 +119,8 @@ LocationXYZ16 gCommandPosition;
 
 bool gMapLandRightsUpdateSuccess;
 
-static void map_update_grass_length(sint32 x, sint32 y, rct_tile_element *mapElement);
-static void map_set_grass_length(sint32 x, sint32 y, rct_tile_element *mapElement, sint32 length);
+static void map_update_grass_length(sint32 x, sint32 y, rct_tile_element *tileElement);
+static void map_set_grass_length(sint32 x, sint32 y, rct_tile_element *tileElement, sint32 length);
 static void clear_elements_at(sint32 x, sint32 y);
 static void translate_3d_to_2d(sint32 rotation, sint32 *x, sint32 *y);
 
@@ -219,13 +219,13 @@ rct_tile_element *map_get_first_element_at(sint32 x, sint32 y)
         log_error("Trying to access element outside of range");
         return NULL;
     }
-    return gMapElementTilePointers[x + y * MAXIMUM_MAP_SIZE_TECHNICAL];
+    return gTileElementTilePointers[x + y * MAXIMUM_MAP_SIZE_TECHNICAL];
 }
 
 rct_tile_element *map_get_nth_element_at(sint32 x, sint32 y, sint32 n)
 {
-    rct_tile_element * mapElement = map_get_first_element_at(x, y);
-    if (mapElement == NULL) {
+    rct_tile_element * tileElement = map_get_first_element_at(x, y);
+    if (tileElement == NULL) {
         return NULL;
     }
     // Iterate through elements on this tile. This has to be walked, rather than
@@ -233,12 +233,12 @@ rct_tile_element *map_get_nth_element_at(sint32 x, sint32 y, sint32 n)
     // and the order of tiles (unlike elements) is not synced over multiplayer.
     while (n >= 0) {
         if (n == 0) {
-            return mapElement;
+            return tileElement;
         }
-        if (tile_element_is_last_for_tile(mapElement)) {
+        if (tile_element_is_last_for_tile(tileElement)) {
             break;
         }
-        mapElement++;
+        tileElement++;
         n--;
     }
     // The element sought for is not within given tile.
@@ -251,7 +251,7 @@ void map_set_tile_elements(sint32 x, sint32 y, rct_tile_element *elements)
         log_error("Trying to access element outside of range");
         return;
     }
-    gMapElementTilePointers[x + y * MAXIMUM_MAP_SIZE_TECHNICAL] = elements;
+    gTileElementTilePointers[x + y * MAXIMUM_MAP_SIZE_TECHNICAL] = elements;
 }
 
 sint32 tile_element_is_last_for_tile(const rct_tile_element *element)
@@ -328,60 +328,60 @@ void tile_element_set_terrain_edge(rct_tile_element *element, sint32 terrain)
 
 rct_tile_element *map_get_surface_element_at(sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x, y);
+    rct_tile_element *tileElement = map_get_first_element_at(x, y);
 
-    if (mapElement == NULL)
+    if (tileElement == NULL)
         return NULL;
 
     // Find the first surface element
-    while (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SURFACE) {
-        if (tile_element_is_last_for_tile(mapElement))
+    while (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SURFACE) {
+        if (tile_element_is_last_for_tile(tileElement))
             return NULL;
 
-        mapElement++;
+        tileElement++;
     }
 
-    return mapElement;
+    return tileElement;
 }
 
 rct_tile_element* map_get_path_element_at(sint32 x, sint32 y, sint32 z){
-    rct_tile_element *mapElement = map_get_first_element_at(x, y);
+    rct_tile_element *tileElement = map_get_first_element_at(x, y);
 
-    if (mapElement == NULL)
+    if (tileElement == NULL)
         return NULL;
 
     // Find the path element at known z
     do {
-        if (mapElement->flags & TILE_ELEMENT_FLAG_GHOST)
+        if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
 
 rct_tile_element* map_get_banner_element_at(sint32 x, sint32 y, sint32 z, uint8 position) {
-    rct_tile_element *mapElement = map_get_first_element_at(x, y);
+    rct_tile_element *tileElement = map_get_first_element_at(x, y);
 
-    if (mapElement == NULL)
+    if (tileElement == NULL)
         return NULL;
 
     // Find the banner element at known z and position
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_BANNER)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_BANNER)
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
-        if (mapElement->properties.banner.position != position)
+        if (tileElement->properties.banner.position != position)
             continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
@@ -393,10 +393,10 @@ rct_tile_element* map_get_banner_element_at(sint32 x, sint32 y, sint32 z, uint8
 void map_init(sint32 size)
 {
     gNumMapAnimations = 0;
-    gNextFreeMapElementPointerIndex = 0;
+    gNextFreeTileElementPointerIndex = 0;
 
     for (sint32 i = 0; i < MAX_TILE_TILE_ELEMENT_POINTERS; i++) {
-        rct_tile_element *tile_element = &gMapElements[i];
+        rct_tile_element *tile_element = &gTileElements[i];
         tile_element->type = (TILE_ELEMENT_TYPE_SURFACE << 2);
         tile_element->flags = TILE_ELEMENT_FLAG_LAST_TILE;
         tile_element->base_height = 14;
@@ -467,10 +467,10 @@ void map_count_remaining_land_rights()
  */
 void map_strip_ghost_flag_from_elements()
 {
-    rct_tile_element *mapElement = gMapElements;
+    rct_tile_element *tileElement = gTileElements;
     do {
-        mapElement->flags &= ~TILE_ELEMENT_FLAG_GHOST;
-    } while (++mapElement < gMapElements + MAX_TILE_ELEMENTS);
+        tileElement->flags &= ~TILE_ELEMENT_FLAG_GHOST;
+    } while (++tileElement < gTileElements + MAX_TILE_ELEMENTS);
 }
 
 /**
@@ -482,19 +482,19 @@ void map_update_tile_pointers()
     sint32 i, x, y;
 
     for (i = 0; i < MAX_TILE_TILE_ELEMENT_POINTERS; i++) {
-        gMapElementTilePointers[i] = TILE_UNDEFINED_TILE_ELEMENT;
+        gTileElementTilePointers[i] = TILE_UNDEFINED_TILE_ELEMENT;
     }
 
-    rct_tile_element *mapElement = gMapElements;
-    rct_tile_element **tile = gMapElementTilePointers;
+    rct_tile_element *tileElement = gTileElements;
+    rct_tile_element **tile = gTileElementTilePointers;
     for (y = 0; y < MAXIMUM_MAP_SIZE_TECHNICAL; y++) {
         for (x = 0; x < MAXIMUM_MAP_SIZE_TECHNICAL; x++) {
-            *tile++ = mapElement;
-            while (!tile_element_is_last_for_tile(mapElement++));
+            *tile++ = tileElement;
+            while (!tile_element_is_last_for_tile(tileElement++));
         }
     }
 
-    gNextFreeMapElement = mapElement;
+    gNextFreeTileElement = tileElement;
 }
 
 /**
@@ -507,7 +507,7 @@ void map_update_tile_pointers()
  */
 sint32 tile_element_height(sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     // Off the map
     if ((unsigned)x >= 8192 || (unsigned)y >= 8192)
@@ -518,17 +518,17 @@ sint32 tile_element_height(sint32 x, sint32 y)
     sint32 y_tile = y & 0xFFFFFFE0;
 
     // Get the surface element for the tile
-    mapElement = map_get_surface_element_at(x_tile / 32, y_tile / 32);
+    tileElement = map_get_surface_element_at(x_tile / 32, y_tile / 32);
 
-    if (mapElement == NULL) {
+    if (tileElement == NULL) {
         return 16;
     }
 
     uint32 height =
-        (map_get_water_height(mapElement) << 20) |
-        (mapElement->base_height << 3);
+        (map_get_water_height(tileElement) << 20) |
+        (tileElement->base_height << 3);
 
-    uint32 slope = (mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK);
+    uint32 slope = (tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK);
     uint8 extra_height = (slope & 0x10) >> 4; // 0x10 is the 5th bit - sets slope to double height
     // Remove the extra height bit
     slope &= 0xF;
@@ -651,45 +651,45 @@ sint32 tile_element_height(sint32 x, sint32 y)
 void sub_68B089()
 {
     sint32 i;
-    rct_tile_element *mapElementFirst, *mapElement;
+    rct_tile_element *tileElementFirst, *tileElement;
 
     if (gTrackDesignSaveMode)
         return;
 
-    i = gNextFreeMapElementPointerIndex;
+    i = gNextFreeTileElementPointerIndex;
     do {
         i++;
         if (i >= MAX_TILE_TILE_ELEMENT_POINTERS)
             i = 0;
-    } while (gMapElementTilePointers[i] == TILE_UNDEFINED_TILE_ELEMENT);
-    gNextFreeMapElementPointerIndex = i;
+    } while (gTileElementTilePointers[i] == TILE_UNDEFINED_TILE_ELEMENT);
+    gNextFreeTileElementPointerIndex = i;
 
-    mapElementFirst = mapElement = gMapElementTilePointers[i];
+    tileElementFirst = tileElement = gTileElementTilePointers[i];
     do {
-        mapElement--;
-        if (mapElement < gMapElements)
+        tileElement--;
+        if (tileElement < gTileElements)
             break;
-    } while (mapElement->base_height == 255);
-    mapElement++;
+    } while (tileElement->base_height == 255);
+    tileElement++;
 
-    if (mapElement == mapElementFirst)
+    if (tileElement == tileElementFirst)
         return;
 
     //
-    gMapElementTilePointers[i] = mapElement;
+    gTileElementTilePointers[i] = tileElement;
     do {
-        *mapElement = *mapElementFirst;
-        mapElementFirst->base_height = 255;
+        *tileElement = *tileElementFirst;
+        tileElementFirst->base_height = 255;
 
-        mapElementFirst++;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        tileElementFirst++;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
-    mapElement = gNextFreeMapElement;
+    tileElement = gNextFreeTileElement;
     do {
-        mapElement--;
-    } while (mapElement->base_height == 255);
-    mapElement++;
-    gNextFreeMapElement = mapElement;
+        tileElement--;
+    } while (tileElement->base_height == 255);
+    tileElement++;
+    gNextFreeTileElement = tileElement;
 }
 
 
@@ -699,28 +699,28 @@ void sub_68B089()
  */
 sint32 map_coord_is_connected(sint32 x, sint32 y, sint32 z, uint8 faceDirection)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x, y);
+    rct_tile_element *tileElement = map_get_first_element_at(x, y);
 
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        rct_tile_element_path_properties props = mapElement->properties.path;
+        rct_tile_element_path_properties props = tileElement->properties.path;
         uint8 pathType = props.type >> 2;
         uint8 pathDirection = props.type & 3;
 
         if (pathType & 1) {
             if (pathDirection == faceDirection) {
-                if (z == mapElement->base_height + 2)
+                if (z == tileElement->base_height + 2)
                     return 1;
-            } else if ((pathDirection ^ 2) == faceDirection && z == mapElement->base_height) {
+            } else if ((pathDirection ^ 2) == faceDirection && z == tileElement->base_height) {
                 return 1;
             }
         } else {
-            if (z == mapElement->base_height)
+            if (z == tileElement->base_height)
                 return 1;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return 0;
 }
@@ -806,14 +806,14 @@ bool map_is_location_owned(sint32 x, sint32 y, sint32 z)
 {
     // This check is to avoid throwing lots of messages in logs.
     if (map_is_location_valid(x, y)) {
-        rct_tile_element *mapElement = map_get_surface_element_at(x / 32, y / 32);
-        if (mapElement != NULL) {
-            if (mapElement->properties.surface.ownership & OWNERSHIP_OWNED)
+        rct_tile_element *tileElement = map_get_surface_element_at(x / 32, y / 32);
+        if (tileElement != NULL) {
+            if (tileElement->properties.surface.ownership & OWNERSHIP_OWNED)
                 return true;
 
-            if (mapElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) {
+            if (tileElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) {
                 z /= 8;
-                if (z < mapElement->base_height || z - 2 > mapElement->base_height)
+                if (z < tileElement->base_height || z - 2 > tileElement->base_height)
                     return true;
             }
         }
@@ -830,10 +830,10 @@ bool map_is_location_owned(sint32 x, sint32 y, sint32 z)
 bool map_is_location_in_park(sint32 x, sint32 y)
 {
     if (map_is_location_valid(x, y)) {
-        rct_tile_element *mapElement = map_get_surface_element_at(x / 32, y / 32);
-        if (mapElement == NULL)
+        rct_tile_element *tileElement = map_get_surface_element_at(x / 32, y / 32);
+        if (tileElement == NULL)
             return false;
-        if (mapElement->properties.surface.ownership & OWNERSHIP_OWNED)
+        if (tileElement->properties.surface.ownership & OWNERSHIP_OWNED)
             return true;
     }
 
@@ -844,12 +844,12 @@ bool map_is_location_in_park(sint32 x, sint32 y)
 bool map_is_location_owned_or_has_rights(sint32 x, sint32 y)
 {
     if (map_is_location_valid(x, y)) {
-        rct_tile_element *mapElement = map_get_surface_element_at(x / 32, y / 32);
-        if (mapElement == NULL) {
+        rct_tile_element *tileElement = map_get_surface_element_at(x / 32, y / 32);
+        if (tileElement == NULL) {
             return false;
         }
-        if (mapElement->properties.surface.ownership & OWNERSHIP_OWNED) return true;
-        if (mapElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) return true;
+        if (tileElement->properties.surface.ownership & OWNERSHIP_OWNED) return true;
+        if (tileElement->properties.surface.ownership & OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED) return true;
     }
     return false;
 }
@@ -1073,17 +1073,17 @@ void game_command_set_large_scenery_colour(sint32* eax, sint32* ebx, sint32* ecx
         }
 
         if(flags & GAME_COMMAND_FLAG_APPLY){
-            rct_tile_element* mapElement = map_get_large_scenery_segment(
+            rct_tile_element* tileElement = map_get_large_scenery_segment(
                 currentTile.x,
                 currentTile.y,
                 base_height,
                 tile_element_direction,
                 i);
 
-            mapElement->properties.scenerymultiple.colour[0] &= 0xE0;
-            mapElement->properties.scenerymultiple.colour[0] |= colour1;
-            mapElement->properties.scenerymultiple.colour[1] &= 0xE0;
-            mapElement->properties.scenerymultiple.colour[1] |= colour2;
+            tileElement->properties.scenerymultiple.colour[0] &= 0xE0;
+            tileElement->properties.scenerymultiple.colour[0] |= colour1;
+            tileElement->properties.scenerymultiple.colour[1] &= 0xE0;
+            tileElement->properties.scenerymultiple.colour[1] |= colour2;
 
             map_invalidate_tile_full(currentTile.x, currentTile.y);
         }
@@ -1103,21 +1103,21 @@ static money32 map_clear_scenery_from_tile(sint32 x, sint32 y, sint32 clear, sin
 {
     sint32 type;
     money32 cost, totalCost;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     totalCost = 0;
 
 restart_from_beginning:
-    mapElement = map_get_first_element_at(x, y);
+    tileElement = map_get_first_element_at(x, y);
     do {
-        type = tile_element_get_type(mapElement);
+        type = tile_element_get_type(tileElement);
         switch (type) {
         case TILE_ELEMENT_TYPE_PATH:
             if (clear & (1 << 2)) {
                 sint32 eax = x * 32;
                 sint32 ebx = flags;
                 sint32 ecx = y * 32;
-                sint32 edx = mapElement->base_height;
+                sint32 edx = tileElement->base_height;
                 sint32 edi = 0, ebp = 0;
                 cost = game_do_command(eax, ebx, ecx, edx, GAME_COMMAND_REMOVE_PATH, edi, ebp);
 
@@ -1131,9 +1131,9 @@ restart_from_beginning:
         case TILE_ELEMENT_TYPE_SCENERY:
             if (clear & (1 << 0)) {
                 sint32 eax = x * 32;
-                sint32 ebx = (mapElement->type << 8) | flags;
+                sint32 ebx = (tileElement->type << 8) | flags;
                 sint32 ecx = y * 32;
-                sint32 edx = (mapElement->properties.scenery.type << 8) | (mapElement->base_height);
+                sint32 edx = (tileElement->properties.scenery.type << 8) | (tileElement->base_height);
                 sint32 edi = 0, ebp = 0;
                 cost = game_do_command(eax, ebx, ecx, edx, GAME_COMMAND_REMOVE_SCENERY, edi, ebp);
 
@@ -1150,7 +1150,7 @@ restart_from_beginning:
                 sint32 eax = x * 32;
                 sint32 ebx = flags;
                 sint32 ecx = y * 32;
-                sint32 edx = (mapElement->base_height << 8) | (tile_element_get_direction(mapElement));
+                sint32 edx = (tileElement->base_height << 8) | (tile_element_get_direction(tileElement));
                 sint32 edi = 0, ebp = 0;
                 cost = game_do_command(eax, ebx, ecx, edx, GAME_COMMAND_REMOVE_WALL, edi, ebp);
 
@@ -1165,9 +1165,9 @@ restart_from_beginning:
         case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
             if (clear & (1 << 1)) {
                 sint32 eax = x * 32;
-                sint32 ebx = flags | ((tile_element_get_direction(mapElement)) << 8);
+                sint32 ebx = flags | ((tile_element_get_direction(tileElement)) << 8);
                 sint32 ecx = y * 32;
-                sint32 edx = mapElement->base_height | ((mapElement->properties.scenerymultiple.type >> 10) << 8);
+                sint32 edx = tileElement->base_height | ((tileElement->properties.scenerymultiple.type >> 10) << 8);
                 sint32 edi = 0, ebp = 0;
                 cost = game_do_command(eax, ebx | (1 << 7), ecx, edx, GAME_COMMAND_REMOVE_LARGE_SCENERY, edi, ebp);
 
@@ -1180,7 +1180,7 @@ restart_from_beginning:
 
             } break;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return totalCost;
 }
@@ -1190,16 +1190,16 @@ restart_from_beginning:
  * when using the clear scenery tool with large scenery.
  */
 static void map_reset_clear_large_scenery_flag(){
-    rct_tile_element* mapElement;
+    rct_tile_element* tileElement;
     // TODO: Improve efficiency of this
     for (sint32 y = 0; y < MAXIMUM_MAP_SIZE_TECHNICAL; y++) {
         for (sint32 x = 0; x < MAXIMUM_MAP_SIZE_TECHNICAL; x++) {
-            mapElement = map_get_first_element_at(x, y);
+            tileElement = map_get_first_element_at(x, y);
             do {
-                if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE) {
-                    mapElement->flags &= ~(1 << 6);
+                if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY_MULTIPLE) {
+                    tileElement->flags &= ~(1 << 6);
                 }
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
         }
     }
 }
@@ -1319,12 +1319,12 @@ static money32 map_change_surface_style(sint32 x0, sint32 y0, sint32 x1, sint32
                 if (!map_is_location_in_park(x, y)) continue;
             }
 
-            rct_tile_element* mapElement = map_get_surface_element_at(x / 32, y / 32);
+            rct_tile_element* tileElement = map_get_surface_element_at(x / 32, y / 32);
 
             if (surfaceStyle != 0xFF){
                 uint8 cur_terrain = (
-                    tile_element_get_direction(mapElement) << 3) |
-                    (mapElement->properties.surface.terrain >> 5);
+                    tile_element_get_direction(tileElement) << 3) |
+                    (tileElement->properties.surface.terrain >> 5);
 
                 if (surfaceStyle != cur_terrain) {
                     // Prevent network-originated value of surfaceStyle from causing
@@ -1335,14 +1335,14 @@ static money32 map_change_surface_style(sint32 x0, sint32 y0, sint32 x1, sint32
                     }
                     surfaceCost += TerrainPricing[style];
                     if (flags & 1){
-                        mapElement->properties.surface.terrain &= TILE_ELEMENT_WATER_HEIGHT_MASK;
-                        mapElement->type &= TILE_ELEMENT_QUADRANT_MASK | TILE_ELEMENT_TYPE_MASK;
+                        tileElement->properties.surface.terrain &= TILE_ELEMENT_WATER_HEIGHT_MASK;
+                        tileElement->type &= TILE_ELEMENT_QUADRANT_MASK | TILE_ELEMENT_TYPE_MASK;
 
                         //Save the new terrain
-                        mapElement->properties.surface.terrain |= surfaceStyle << 5;
+                        tileElement->properties.surface.terrain |= surfaceStyle << 5;
 
                         //Save the new direction mask
-                        mapElement->type |= (surfaceStyle >> 3) & TILE_ELEMENT_DIRECTION_MASK;
+                        tileElement->type |= (surfaceStyle >> 3) & TILE_ELEMENT_DIRECTION_MASK;
 
                         map_invalidate_tile_full(x, y);
                         footpath_remove_litter(x, y, tile_element_height(x, y));
@@ -1352,21 +1352,21 @@ static money32 map_change_surface_style(sint32 x0, sint32 y0, sint32 x1, sint32
 
             if (edgeStyle != 0xFF) {
                 uint8 currentEdge =
-                    ((mapElement->type & 0x80) >> 4) |
-                    (mapElement->properties.surface.slope >> 5);
+                    ((tileElement->type & 0x80) >> 4) |
+                    (tileElement->properties.surface.slope >> 5);
 
                 if (edgeStyle != currentEdge){
                     edgeCost += 100;
 
                     if (flags & 1){
-                        mapElement->properties.surface.slope &= TILE_ELEMENT_SLOPE_MASK;
-                        mapElement->type &= 0x7F;
+                        tileElement->properties.surface.slope &= TILE_ELEMENT_SLOPE_MASK;
+                        tileElement->type &= 0x7F;
 
                         //Save edge style
-                        mapElement->properties.surface.slope |= edgeStyle << 5;
+                        tileElement->properties.surface.slope |= edgeStyle << 5;
 
                         //Save ???
-                        mapElement->type |= (edgeStyle << 4) & 0x80;
+                        tileElement->type |= (edgeStyle << 4) & 0x80;
                         map_invalidate_tile_full(x, y);
                     }
                 }
@@ -1374,12 +1374,12 @@ static money32 map_change_surface_style(sint32 x0, sint32 y0, sint32 x1, sint32
 
             if (flags & 1)
             {
-                if (!(mapElement->properties.surface.terrain & TILE_ELEMENT_SURFACE_TERRAIN_MASK))
+                if (!(tileElement->properties.surface.terrain & TILE_ELEMENT_SURFACE_TERRAIN_MASK))
                 {
-                    if (!(tile_element_get_direction(mapElement)))
+                    if (!(tile_element_get_direction(tileElement)))
                     {
-                        if ((mapElement->properties.surface.grass_length & 7) != GRASS_LENGTH_CLEAR_0) {
-                            mapElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
+                        if ((tileElement->properties.surface.grass_length & 7) != GRASS_LENGTH_CLEAR_0) {
+                            tileElement->properties.surface.grass_length = GRASS_LENGTH_CLEAR_0;
                             map_invalidate_tile_full(x, y);
                         }
                     }
@@ -1487,16 +1487,16 @@ static sint32 map_get_corner_height(sint32 z, sint32 slope, sint32 direction)
     return z;
 }
 
-static sint32 tile_element_get_corner_height(rct_tile_element *mapElement, sint32 direction)
+static sint32 tile_element_get_corner_height(rct_tile_element *tileElement, sint32 direction)
 {
-    sint32 z = mapElement->base_height;
-    sint32 slope = mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK;
+    sint32 z = tileElement->base_height;
+    sint32 slope = tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK;
     return map_get_corner_height(z, slope, direction);
 }
 
 static money32 map_set_land_height(sint32 flags, sint32 x, sint32 y, sint32 height, sint32 style, sint32 selectionType)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     if (game_is_paused() && !gCheatsBuildInPauseMode) {
         gGameCommandErrorText = STR_CONSTRUCTION_NOT_POSSIBLE_WHILE_GAME_IS_PAUSED;
@@ -1550,44 +1550,44 @@ static money32 map_set_land_height(sint32 flags, sint32 x, sint32 y, sint32 heig
 
     if (!gCheatsDisableClearanceChecks) {
         //Check for obstructing scenery
-        mapElement = map_get_first_element_at(x / 32, y / 32);
+        tileElement = map_get_first_element_at(x / 32, y / 32);
         do {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
                 continue;
-            if (height > mapElement->clearance_height)
+            if (height > tileElement->clearance_height)
                 continue;
-            if (height + 4 < mapElement->base_height)
+            if (height + 4 < tileElement->base_height)
                 continue;
-            rct_scenery_entry *sceneryEntry = get_small_scenery_entry(mapElement->properties.scenery.type);
+            rct_scenery_entry *sceneryEntry = get_small_scenery_entry(tileElement->properties.scenery.type);
             if (sceneryEntry->small_scenery.height > 64 && gParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL)
             {
-                map_obstruction_set_error_text(mapElement);
+                map_obstruction_set_error_text(tileElement);
                 return MONEY32_UNDEFINED;
             }
             cost += MONEY(sceneryEntry->small_scenery.removal_price, 0);
             if (flags & GAME_COMMAND_FLAG_APPLY)
-                tile_element_remove(mapElement--);
-        } while (!tile_element_is_last_for_tile(mapElement++));
+                tile_element_remove(tileElement--);
+        } while (!tile_element_is_last_for_tile(tileElement++));
     }
 
     //Check for ride support limits
     if(gCheatsDisableSupportLimits==false)
     {
-        mapElement = map_get_first_element_at(x / 32, y / 32);
+        tileElement = map_get_first_element_at(x / 32, y / 32);
         do{
-            if(tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+            if(tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                 continue;
-            sint32 rideIndex = mapElement->properties.track.ride_index;
+            sint32 rideIndex = tileElement->properties.track.ride_index;
             sint32 maxHeight = get_ride_entry_by_ride(get_ride(rideIndex))->max_height;
             if(maxHeight == 0)
                 maxHeight = RideData5[get_ride(rideIndex)->type].max_height;
-            sint32 zDelta = mapElement->clearance_height - height;
+            sint32 zDelta = tileElement->clearance_height - height;
             if(zDelta >= 0 && zDelta/2 > maxHeight)
             {
                 gGameCommandErrorText = STR_SUPPORTS_CANT_BE_EXTENDED;
                 return MONEY32_UNDEFINED;
             }
-        }while(!tile_element_is_last_for_tile(mapElement++));
+        }while(!tile_element_is_last_for_tile(tileElement++));
     }
 
     uint8 zCorner = height; //z position of highest corner of tile
@@ -1631,33 +1631,33 @@ static money32 map_set_land_height(sint32 flags, sint32 x, sint32 y, sint32 heig
     }
 
     if (!gCheatsDisableClearanceChecks) {
-        mapElement = map_get_first_element_at(x / 32, y / 32);
+        tileElement = map_get_first_element_at(x / 32, y / 32);
         do {
-            sint32 elementType = tile_element_get_type(mapElement);
+            sint32 elementType = tile_element_get_type(tileElement);
 
             if (elementType == TILE_ELEMENT_TYPE_WALL)
                 continue;
             if (elementType == TILE_ELEMENT_TYPE_SCENERY)
                 continue;
-            if (mapElement->flags & 0x10)
+            if (tileElement->flags & 0x10)
                 continue;
-            if (mapElement == surfaceElement)
+            if (tileElement == surfaceElement)
                 continue;
-            if (mapElement > surfaceElement)
+            if (tileElement > surfaceElement)
             {
-                if (zCorner > mapElement->base_height)
+                if (zCorner > tileElement->base_height)
                 {
-                    map_obstruction_set_error_text(mapElement);
+                    map_obstruction_set_error_text(tileElement);
                     return MONEY32_UNDEFINED;
                 }
                 continue;
             }
-            if (height < mapElement->clearance_height)
+            if (height < tileElement->clearance_height)
             {
-                map_obstruction_set_error_text(mapElement);
+                map_obstruction_set_error_text(tileElement);
                 return MONEY32_UNDEFINED;
             }
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
     }
 
     for (sint32 i = 0; i < 4; i += 1) {
@@ -1896,9 +1896,9 @@ static money32 lower_land(sint32 flags, sint32 x, sint32 y, sint32 z, sint32 ax,
     return cost;
 }
 
-sint32 map_get_water_height(const rct_tile_element * mapElement)
+sint32 map_get_water_height(const rct_tile_element * tileElement)
 {
-    return mapElement->properties.surface.terrain & TILE_ELEMENT_WATER_HEIGHT_MASK;
+    return tileElement->properties.surface.terrain & TILE_ELEMENT_WATER_HEIGHT_MASK;
 }
 
 money32 raise_water(sint16 x0, sint16 y0, sint16 x1, sint16 y1, uint8 flags)
@@ -2096,10 +2096,10 @@ void game_command_lower_land(sint32* eax, sint32* ebx, sint32* ecx, sint32* edx,
     );
 }
 
-static money32 smooth_land_tile(sint32 direction, uint8 flags, sint32 x, sint32 y, rct_tile_element * mapElement, bool raiseLand)
+static money32 smooth_land_tile(sint32 direction, uint8 flags, sint32 x, sint32 y, rct_tile_element * tileElement, bool raiseLand)
 {
-    sint32 targetBaseZ = mapElement->base_height;
-    sint32 slope = mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK;
+    sint32 targetBaseZ = tileElement->base_height;
+    sint32 slope = tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK;
     if (raiseLand) {
         slope = tile_element_raise_styles[direction][slope];
         if (slope & 0x20) {
@@ -2121,7 +2121,7 @@ static money32 smooth_land_row_by_edge(sint32 flags, sint32 x, sint32 y, sint32
 {
     uint8 shouldContinue = 0xF;
     sint32 landChangePerTile = raiseLand ? -2 : 2;
-    rct_tile_element *mapElement, *nextMapElement;
+    rct_tile_element *tileElement, *nextTileElement;
     money32 totalCost = 0;
     money32 result;
 
@@ -2129,21 +2129,21 @@ static money32 smooth_land_row_by_edge(sint32 flags, sint32 x, sint32 y, sint32
     if (!map_is_location_valid(x, y) || !map_is_location_valid(x + stepX, y + stepY)) {
         return 0;
     }
-    mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-    nextMapElement = map_get_surface_element_at((x + stepX) >> 5, (y + stepY) >> 5);
-    if (mapElement == NULL || nextMapElement == NULL) {
+    tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+    nextTileElement = map_get_surface_element_at((x + stepX) >> 5, (y + stepY) >> 5);
+    if (tileElement == NULL || nextTileElement == NULL) {
         return 0;
     }
-    if (tile_element_get_corner_height(mapElement, checkDirection1) != expectedLandHeight1 + (raiseLand ? -2 : 2)) {
+    if (tile_element_get_corner_height(tileElement, checkDirection1) != expectedLandHeight1 + (raiseLand ? -2 : 2)) {
         shouldContinue &= ~0x1;
     }
-    if (tile_element_get_corner_height(mapElement, checkDirection2) != expectedLandHeight2 + (raiseLand ? -2 : 2)) {
+    if (tile_element_get_corner_height(tileElement, checkDirection2) != expectedLandHeight2 + (raiseLand ? -2 : 2)) {
         shouldContinue &= ~0x2;
     }
-    if (tile_element_get_corner_height(mapElement, checkDirection1) != tile_element_get_corner_height(nextMapElement, direction1)) {
+    if (tile_element_get_corner_height(tileElement, checkDirection1) != tile_element_get_corner_height(nextTileElement, direction1)) {
         shouldContinue &= ~0x1;
     }
-    if (tile_element_get_corner_height(mapElement, checkDirection2) != tile_element_get_corner_height(nextMapElement, direction2)) {
+    if (tile_element_get_corner_height(tileElement, checkDirection2) != tile_element_get_corner_height(nextTileElement, direction2)) {
         shouldContinue &= ~0x2;
     }
     while ((shouldContinue & 0x3) != 0)
@@ -2158,29 +2158,29 @@ static money32 smooth_land_row_by_edge(sint32 flags, sint32 x, sint32 y, sint32
         }
         else
         {
-            mapElement = nextMapElement;
-            nextMapElement = map_get_surface_element_at((x + stepX) >> 5, (y + stepY) >> 5);
-            if (nextMapElement == NULL) {
+            tileElement = nextTileElement;
+            nextTileElement = map_get_surface_element_at((x + stepX) >> 5, (y + stepY) >> 5);
+            if (nextTileElement == NULL) {
                 shouldContinue &= ~0x3;
             }
-            if (tile_element_get_corner_height(mapElement, direction1) + landChangePerTile != tile_element_get_corner_height(mapElement, checkDirection1)) {
+            if (tile_element_get_corner_height(tileElement, direction1) + landChangePerTile != tile_element_get_corner_height(tileElement, checkDirection1)) {
                 shouldContinue &= ~0x1;
             }
-            if (tile_element_get_corner_height(mapElement, direction2) + landChangePerTile != tile_element_get_corner_height(mapElement, checkDirection2)) {
+            if (tile_element_get_corner_height(tileElement, direction2) + landChangePerTile != tile_element_get_corner_height(tileElement, checkDirection2)) {
                 shouldContinue &= ~0x2;
             }
-            if ((shouldContinue & 0x1) && tile_element_get_corner_height(mapElement, checkDirection1) != tile_element_get_corner_height(nextMapElement, direction1)) {
+            if ((shouldContinue & 0x1) && tile_element_get_corner_height(tileElement, checkDirection1) != tile_element_get_corner_height(nextTileElement, direction1)) {
                 shouldContinue &= ~0x1;
             }
-            if ((shouldContinue & 0x2) && tile_element_get_corner_height(mapElement, checkDirection2) != tile_element_get_corner_height(nextMapElement, direction2)) {
+            if ((shouldContinue & 0x2) && tile_element_get_corner_height(tileElement, checkDirection2) != tile_element_get_corner_height(nextTileElement, direction2)) {
                 shouldContinue &= ~0x2;
             }
         }
         expectedLandHeight1 += landChangePerTile;
 
         // change land of current tile
-        sint32 targetBaseZ = mapElement->base_height;
-        sint32 slope = mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK;
+        sint32 targetBaseZ = tileElement->base_height;
+        sint32 slope = tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK;
         sint32 oldSlope = slope;
         if (raiseLand) {
             if (shouldContinue & 0x4) {
@@ -2191,7 +2191,7 @@ static money32 smooth_land_row_by_edge(sint32 flags, sint32 x, sint32 y, sint32
                 }
             }
             if ((shouldContinue & 0x8) &&
-                    map_get_corner_height(mapElement->base_height, oldSlope, direction2) ==
+                    map_get_corner_height(tileElement->base_height, oldSlope, direction2) ==
                     map_get_corner_height(targetBaseZ, slope, direction2))
             {
                 slope = tile_element_raise_styles[direction2][slope];
@@ -2211,7 +2211,7 @@ static money32 smooth_land_row_by_edge(sint32 flags, sint32 x, sint32 y, sint32
                 }
             }
             if ((shouldContinue & 0x8) &&
-                    map_get_corner_height(mapElement->base_height, oldSlope, direction2) ==
+                    map_get_corner_height(tileElement->base_height, oldSlope, direction2) ==
                     map_get_corner_height(targetBaseZ, slope, direction2))
             {
                 slope = tile_element_lower_styles[direction2][slope];
@@ -2232,7 +2232,7 @@ static money32 smooth_land_row_by_edge(sint32 flags, sint32 x, sint32 y, sint32
 static money32 smooth_land_row_by_corner(sint32 flags, sint32 x, sint32 y, sint32 expectedLandHeight, sint32 stepX, sint32 stepY, sint32 direction, sint32 checkDirection, bool raiseLand)
 {
     bool shouldContinue = true;
-    rct_tile_element *mapElement, *nextMapElement;
+    rct_tile_element *tileElement, *nextTileElement;
     money32 totalCost = 0;
     money32 result;
     sint32 landChangePerTile;
@@ -2249,15 +2249,15 @@ static money32 smooth_land_row_by_corner(sint32 flags, sint32 x, sint32 y, sint3
     if (!map_is_location_valid(x, y) || !map_is_location_valid(x + stepX, y + stepY)) {
         return 0;
     }
-    mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-    nextMapElement = map_get_surface_element_at((x + stepX) >> 5, (y + stepY) >> 5);
-    if (mapElement == NULL || nextMapElement == NULL) {
+    tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+    nextTileElement = map_get_surface_element_at((x + stepX) >> 5, (y + stepY) >> 5);
+    if (tileElement == NULL || nextTileElement == NULL) {
         return 0;
     }
-    if (tile_element_get_corner_height(mapElement, checkDirection) != expectedLandHeight + (raiseLand ? -2 : 2)) {
+    if (tile_element_get_corner_height(tileElement, checkDirection) != expectedLandHeight + (raiseLand ? -2 : 2)) {
         return 0;
     }
-    if (tile_element_get_corner_height(mapElement, checkDirection) != tile_element_get_corner_height(nextMapElement, direction)) {
+    if (tile_element_get_corner_height(tileElement, checkDirection) != tile_element_get_corner_height(nextTileElement, direction)) {
         return 0;
     }
     while (shouldContinue)
@@ -2271,15 +2271,15 @@ static money32 smooth_land_row_by_corner(sint32 flags, sint32 x, sint32 y, sint3
         }
         else
         {
-            mapElement = nextMapElement;
-            nextMapElement = map_get_surface_element_at((x + stepX) >> 5, (y + stepY) >> 5);
-            if (nextMapElement == NULL) {
+            tileElement = nextTileElement;
+            nextTileElement = map_get_surface_element_at((x + stepX) >> 5, (y + stepY) >> 5);
+            if (nextTileElement == NULL) {
                 shouldContinue = false;
             }
-            if (tile_element_get_corner_height(mapElement, direction) + landChangePerTile != tile_element_get_corner_height(mapElement, checkDirection)) {
+            if (tile_element_get_corner_height(tileElement, direction) + landChangePerTile != tile_element_get_corner_height(tileElement, checkDirection)) {
                 shouldContinue = false;
             }
-            if (shouldContinue && tile_element_get_corner_height(mapElement, checkDirection) != tile_element_get_corner_height(nextMapElement, direction)) {
+            if (shouldContinue && tile_element_get_corner_height(tileElement, checkDirection) != tile_element_get_corner_height(nextTileElement, direction)) {
                 shouldContinue = false;
             }
         }
@@ -2290,7 +2290,7 @@ static money32 smooth_land_row_by_corner(sint32 flags, sint32 x, sint32 y, sint3
         }
         expectedLandHeight += landChangePerTile;
         // change land of current tile
-        result = smooth_land_tile(direction, flags, x, y, mapElement, raiseLand);
+        result = smooth_land_tile(direction, flags, x, y, tileElement, raiseLand);
         if (result != MONEY32_UNDEFINED) {
             totalCost += result;
         }
@@ -2321,8 +2321,8 @@ static money32 smooth_land(sint32 flags, sint32 centreX, sint32 centreY, sint32
     money32 totalCost = 0;
     money32 result;
 
-    rct_tile_element *mapElement = map_get_surface_element_at(mapLeft >> 5, mapTop >> 5);
-    if (mapElement == NULL)
+    rct_tile_element *tileElement = map_get_surface_element_at(mapLeft >> 5, mapTop >> 5);
+    if (tileElement == NULL)
     {
         log_warning("Invalid coordinates for land smoothing, x = %d, y = %d", mapLeft, mapTop);
         return MONEY32_UNDEFINED;
@@ -2359,8 +2359,8 @@ static money32 smooth_land(sint32 flags, sint32 centreX, sint32 centreY, sint32
     else
     {
         // One corner tile selected
-        newBaseZ = mapElement->base_height;
-        newSlope = mapElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK;
+        newBaseZ = tileElement->base_height;
+        newSlope = tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_MASK;
         if (commandType == GAME_COMMAND_RAISE_LAND) {
             newSlope = tile_element_raise_styles[command & 0xFF][newSlope];
             if (newSlope & 0x20) {
@@ -2380,16 +2380,16 @@ static money32 smooth_land(sint32 flags, sint32 centreX, sint32 centreY, sint32
     // Then do the smoothing
     if (fullTile) {
         // Smooth the corners
-        sint32 z = clamp(minHeight, tile_element_get_corner_height(mapElement, 2), maxHeight);
+        sint32 z = clamp(minHeight, tile_element_get_corner_height(tileElement, 2), maxHeight);
         totalCost += smooth_land_row_by_corner(flags, mapLeft, mapTop, z, -32, -32, 0, 2, raiseLand);
-        mapElement = map_get_surface_element_at(mapLeft >> 5, mapBottom >> 5);
-        z = clamp(minHeight, tile_element_get_corner_height(mapElement, 3), maxHeight);
+        tileElement = map_get_surface_element_at(mapLeft >> 5, mapBottom >> 5);
+        z = clamp(minHeight, tile_element_get_corner_height(tileElement, 3), maxHeight);
         totalCost += smooth_land_row_by_corner(flags, mapLeft, mapBottom, z, -32, 32, 1, 3, raiseLand);
-        mapElement = map_get_surface_element_at(mapRight >> 5, mapBottom >> 5);
-        z = clamp(minHeight, tile_element_get_corner_height(mapElement, 0), maxHeight);
+        tileElement = map_get_surface_element_at(mapRight >> 5, mapBottom >> 5);
+        z = clamp(minHeight, tile_element_get_corner_height(tileElement, 0), maxHeight);
         totalCost += smooth_land_row_by_corner(flags, mapRight, mapBottom, z, 32, 32, 2, 0, raiseLand);
-        mapElement = map_get_surface_element_at(mapRight >> 5, mapTop >> 5);
-        z = clamp(minHeight, tile_element_get_corner_height(mapElement, 1), maxHeight);
+        tileElement = map_get_surface_element_at(mapRight >> 5, mapTop >> 5);
+        z = clamp(minHeight, tile_element_get_corner_height(tileElement, 1), maxHeight);
         totalCost += smooth_land_row_by_corner(flags, mapRight, mapTop, z, 32, -32, 3, 1, raiseLand);
 
         // Smooth the edges
@@ -2397,33 +2397,33 @@ static money32 smooth_land(sint32 flags, sint32 centreX, sint32 centreY, sint32
         sint32 y, z2;
         for (y = mapTop; y <= mapBottom; y += 32)
         {
-            mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-            z = clamp(minHeight, tile_element_get_corner_height(mapElement, 3), maxHeight);
-            z2 = clamp(minHeight, tile_element_get_corner_height(mapElement, 2), maxHeight);
+            tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+            z = clamp(minHeight, tile_element_get_corner_height(tileElement, 3), maxHeight);
+            z2 = clamp(minHeight, tile_element_get_corner_height(tileElement, 2), maxHeight);
             totalCost += smooth_land_row_by_edge(flags, x, y, z, z2, -32, 0, 0, 1, 3, 2, raiseLand);
         }
         x = mapRight;
         for (y = mapTop; y <= mapBottom; y += 32)
         {
-            mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-            z = clamp(minHeight, tile_element_get_corner_height(mapElement, 1), maxHeight);
-            z2 = clamp(minHeight, tile_element_get_corner_height(mapElement, 0), maxHeight);
+            tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+            z = clamp(minHeight, tile_element_get_corner_height(tileElement, 1), maxHeight);
+            z2 = clamp(minHeight, tile_element_get_corner_height(tileElement, 0), maxHeight);
             totalCost += smooth_land_row_by_edge(flags, x, y, z, z2, 32, 0, 2, 3, 1, 0, raiseLand);
         }
         y = mapTop;
         for (x = mapLeft; x <= mapRight; x += 32)
         {
-            mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-            z = clamp(minHeight, tile_element_get_corner_height(mapElement, 1), maxHeight);
-            z2 = clamp(minHeight, tile_element_get_corner_height(mapElement, 2), maxHeight);
+            tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+            z = clamp(minHeight, tile_element_get_corner_height(tileElement, 1), maxHeight);
+            z2 = clamp(minHeight, tile_element_get_corner_height(tileElement, 2), maxHeight);
             totalCost += smooth_land_row_by_edge(flags, x, y, z, z2, 0, -32, 0, 3, 1, 2, raiseLand);
         }
         y = mapBottom;
         for (x = mapLeft; x <= mapRight; x += 32)
         {
-            mapElement = map_get_surface_element_at(x >> 5, y >> 5);
-            z = clamp(minHeight, tile_element_get_corner_height(mapElement, 0), maxHeight);
-            z2 = clamp(minHeight, tile_element_get_corner_height(mapElement, 3), maxHeight);
+            tileElement = map_get_surface_element_at(x >> 5, y >> 5);
+            z = clamp(minHeight, tile_element_get_corner_height(tileElement, 0), maxHeight);
+            z2 = clamp(minHeight, tile_element_get_corner_height(tileElement, 3), maxHeight);
             totalCost += smooth_land_row_by_edge(flags, x, y, z, z2, 0, 32, 1, 2, 0, 3, raiseLand);
         }
     }
@@ -2851,7 +2851,7 @@ void game_command_place_large_scenery(sint32* eax, sint32* ebx, sint32* ecx, sin
             }
 
             if (tile_num == 0) {
-                gSceneryMapElement = new_tile_element;
+                gSceneryTileElement = new_tile_element;
             }
             map_invalidate_tile_full(curTile.x, curTile.y);
         }
@@ -2866,69 +2866,69 @@ void game_command_place_large_scenery(sint32* eax, sint32* ebx, sint32* ecx, sin
     }
 }
 
-sint32 tile_element_get_station(const rct_tile_element * mapElement)
+sint32 tile_element_get_station(const rct_tile_element * tileElement)
 {
-    return (mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_STATION_INDEX_MASK) >> 4;
+    return (tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_STATION_INDEX_MASK) >> 4;
 }
 
-void tile_element_set_station(rct_tile_element * mapElement, uint32 stationIndex)
+void tile_element_set_station(rct_tile_element * tileElement, uint32 stationIndex)
 {
-    mapElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_STATION_INDEX_MASK;
-    mapElement->properties.track.sequence |= (stationIndex << 4);
+    tileElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_STATION_INDEX_MASK;
+    tileElement->properties.track.sequence |= (stationIndex << 4);
 }
 
-sint32 tile_element_get_track_sequence(const rct_tile_element * mapElement)
+sint32 tile_element_get_track_sequence(const rct_tile_element * tileElement)
 {
-    return mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
+    return tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
 }
 
-void tile_element_set_track_sequence(rct_tile_element * mapElement, sint32 trackSequence)
+void tile_element_set_track_sequence(rct_tile_element * tileElement, sint32 trackSequence)
 {
-    mapElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
-    mapElement->properties.track.sequence |= (trackSequence & MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK);
+    tileElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
+    tileElement->properties.track.sequence |= (trackSequence & MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK);
 }
 
-bool tile_element_get_green_light(const rct_tile_element * mapElement)
+bool tile_element_get_green_light(const rct_tile_element * tileElement)
 {
-    return (mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT) != 0;
+    return (tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT) != 0;
 }
 
-void tile_element_set_green_light(rct_tile_element * mapElement, bool greenLight)
+void tile_element_set_green_light(rct_tile_element * tileElement, bool greenLight)
 {
-    mapElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
+    tileElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
     if (greenLight)
     {
-        mapElement->properties.track.sequence |= MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
+        tileElement->properties.track.sequence |= MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
     }
 }
 
-sint32 tile_element_get_brake_booster_speed(const rct_tile_element *mapElement)
+sint32 tile_element_get_brake_booster_speed(const rct_tile_element *tileElement)
 {
-    return (mapElement->properties.track.sequence >> 4) << 1;
+    return (tileElement->properties.track.sequence >> 4) << 1;
 }
 
-void tile_element_set_brake_booster_speed(rct_tile_element *mapElement, sint32 speed)
+void tile_element_set_brake_booster_speed(rct_tile_element *tileElement, sint32 speed)
 {
-    mapElement->properties.track.sequence = tile_element_get_track_sequence(mapElement) | ((speed >> 1) << 4);
+    tileElement->properties.track.sequence = tile_element_get_track_sequence(tileElement) | ((speed >> 1) << 4);
 }
 
-bool tile_element_is_taking_photo(const rct_tile_element * mapElement)
+bool tile_element_is_taking_photo(const rct_tile_element * tileElement)
 {
-    return (mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK) != 0;
+    return (tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK) != 0;
 }
 
-void tile_element_set_onride_photo_timeout(rct_tile_element * mapElement)
+void tile_element_set_onride_photo_timeout(rct_tile_element * tileElement)
 {
-    mapElement->properties.track.sequence &= MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
-    mapElement->properties.track.sequence |= (3 << 4);
+    tileElement->properties.track.sequence &= MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
+    tileElement->properties.track.sequence |= (3 << 4);
 }
 
-void tile_element_decrement_onride_photo_timout(rct_tile_element * mapElement)
+void tile_element_decrement_onride_photo_timout(rct_tile_element * tileElement)
 {
     // We should only touch the upper 4 bits, avoid underflow into the lower 4.
-    if (mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK)
+    if (tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK)
     {
-        mapElement->properties.track.sequence -= (1 << 4);
+        tileElement->properties.track.sequence -= (1 << 4);
     }
 }
 
@@ -2936,23 +2936,23 @@ void tile_element_decrement_onride_photo_timout(rct_tile_element * mapElement)
  *
  *  rct2: 0x0068B280
  */
-void tile_element_remove(rct_tile_element *mapElement)
+void tile_element_remove(rct_tile_element *tileElement)
 {
     // Replace Nth element by (N+1)th element.
-    // This loop will make mapElement point to the old last element position,
+    // This loop will make tileElement point to the old last element position,
     // after copy it to it's new position
-    if (!tile_element_is_last_for_tile(mapElement)){
+    if (!tile_element_is_last_for_tile(tileElement)){
         do{
-            *mapElement = *(mapElement + 1);
-        } while (!tile_element_is_last_for_tile(++mapElement));
+            *tileElement = *(tileElement + 1);
+        } while (!tile_element_is_last_for_tile(++tileElement));
     }
 
     // Mark the latest element with the last element flag.
-    (mapElement - 1)->flags |= TILE_ELEMENT_FLAG_LAST_TILE;
-    mapElement->base_height = 0xFF;
+    (tileElement - 1)->flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+    tileElement->base_height = 0xFF;
 
-    if ((mapElement + 1) == gNextFreeMapElement){
-        gNextFreeMapElement--;
+    if ((tileElement + 1) == gNextFreeTileElement){
+        gNextFreeTileElement--;
     }
 }
 
@@ -3097,8 +3097,8 @@ void map_reorganise_elements()
     }
 
     num_elements = (uint32)(new_elements_pointer - new_tile_elements);
-    memcpy(gMapElements, new_tile_elements, num_elements * sizeof(rct_tile_element));
-    memset(gMapElements + num_elements, 0, (3 * (MAXIMUM_MAP_SIZE_TECHNICAL * MAXIMUM_MAP_SIZE_TECHNICAL) - num_elements) * sizeof(rct_tile_element));
+    memcpy(gTileElements, new_tile_elements, num_elements * sizeof(rct_tile_element));
+    memset(gTileElements + num_elements, 0, (3 * (MAXIMUM_MAP_SIZE_TECHNICAL * MAXIMUM_MAP_SIZE_TECHNICAL) - num_elements) * sizeof(rct_tile_element));
 
     free(new_tile_elements);
 
@@ -3113,18 +3113,18 @@ void map_reorganise_elements()
  */
 bool map_check_free_elements_and_reorganise(sint32 num_elements)
 {
-    if ((gNextFreeMapElement + num_elements) <= gMapElements + MAX_TILE_ELEMENTS)
+    if ((gNextFreeTileElement + num_elements) <= gTileElements + MAX_TILE_ELEMENTS)
         return true;
 
     for (sint32 i = 1000; i != 0; --i)
         sub_68B089();
 
-    if ((gNextFreeMapElement + num_elements) <= gMapElements + MAX_TILE_ELEMENTS)
+    if ((gNextFreeTileElement + num_elements) <= gTileElements + MAX_TILE_ELEMENTS)
         return true;
 
     map_reorganise_elements();
 
-    if ((gNextFreeMapElement + num_elements) <= gMapElements + MAX_TILE_ELEMENTS)
+    if ((gNextFreeTileElement + num_elements) <= gTileElements + MAX_TILE_ELEMENTS)
         return true;
     else{
         gGameCommandErrorText = STR_ERR_LANDSCAPE_DATA_AREA_FULL;
@@ -3138,55 +3138,55 @@ bool map_check_free_elements_and_reorganise(sint32 num_elements)
  */
 rct_tile_element *tile_element_insert(sint32 x, sint32 y, sint32 z, sint32 flags)
 {
-    rct_tile_element *originalMapElement, *newMapElement, *insertedElement;
+    rct_tile_element *originalTileElement, *newTileElement, *insertedElement;
 
     if (!map_check_free_elements_and_reorganise(1)) {
         log_error("Cannot insert new element");
         return NULL;
     }
 
-    newMapElement = gNextFreeMapElement;
-    originalMapElement = gMapElementTilePointers[y * MAXIMUM_MAP_SIZE_TECHNICAL + x];
+    newTileElement = gNextFreeTileElement;
+    originalTileElement = gTileElementTilePointers[y * MAXIMUM_MAP_SIZE_TECHNICAL + x];
 
     // Set tile index pointer to point to new element block
-    gMapElementTilePointers[y * MAXIMUM_MAP_SIZE_TECHNICAL + x] = newMapElement;
+    gTileElementTilePointers[y * MAXIMUM_MAP_SIZE_TECHNICAL + x] = newTileElement;
 
     // Copy all elements that are below the insert height
-    while (z >= originalMapElement->base_height) {
+    while (z >= originalTileElement->base_height) {
         // Copy over map element
-        *newMapElement = *originalMapElement;
-        originalMapElement->base_height = 255;
-        originalMapElement++;
-        newMapElement++;
+        *newTileElement = *originalTileElement;
+        originalTileElement->base_height = 255;
+        originalTileElement++;
+        newTileElement++;
 
-        if ((newMapElement - 1)->flags & TILE_ELEMENT_FLAG_LAST_TILE) {
+        if ((newTileElement - 1)->flags & TILE_ELEMENT_FLAG_LAST_TILE) {
             // No more elements above the insert element
-            (newMapElement - 1)->flags &= ~TILE_ELEMENT_FLAG_LAST_TILE;
+            (newTileElement - 1)->flags &= ~TILE_ELEMENT_FLAG_LAST_TILE;
             flags |= TILE_ELEMENT_FLAG_LAST_TILE;
             break;
         }
     }
 
     // Insert new map element
-    insertedElement = newMapElement;
-    newMapElement->base_height = z;
-    newMapElement->flags = flags;
-    newMapElement->clearance_height = z;
-    memset(&newMapElement->properties, 0, sizeof(newMapElement->properties));
-    newMapElement++;
+    insertedElement = newTileElement;
+    newTileElement->base_height = z;
+    newTileElement->flags = flags;
+    newTileElement->clearance_height = z;
+    memset(&newTileElement->properties, 0, sizeof(newTileElement->properties));
+    newTileElement++;
 
     // Insert rest of map elements above insert height
     if (!(flags & TILE_ELEMENT_FLAG_LAST_TILE)) {
         do {
             // Copy over map element
-            *newMapElement = *originalMapElement;
-            originalMapElement->base_height = 255;
-            originalMapElement++;
-            newMapElement++;
-        } while (!((newMapElement - 1)->flags & TILE_ELEMENT_FLAG_LAST_TILE));
+            *newTileElement = *originalTileElement;
+            originalTileElement->base_height = 255;
+            originalTileElement++;
+            newTileElement++;
+        } while (!((newTileElement - 1)->flags & TILE_ELEMENT_FLAG_LAST_TILE));
     }
 
-    gNextFreeMapElement = newMapElement;
+    gNextFreeTileElement = newTileElement;
     return insertedElement;
 }
 
@@ -3197,10 +3197,10 @@ rct_tile_element *tile_element_insert(sint32 x, sint32 y, sint32 z, sint32 flags
  */
 bool tile_element_check_address(const rct_tile_element * const element)
 {
-    if (element >= gMapElements
-        && element < gMapElements + MAX_TILE_ELEMENTS
+    if (element >= gTileElements
+        && element < gTileElements + MAX_TILE_ELEMENTS
         // condition below checks alignment
-        && gMapElements + (((uintptr_t)element - (uintptr_t)gMapElements) / sizeof(rct_tile_element)) == element)
+        && gTileElements + (((uintptr_t)element - (uintptr_t)gTileElements) / sizeof(rct_tile_element)) == element)
     {
         return true;
     }
@@ -3211,14 +3211,14 @@ bool tile_element_check_address(const rct_tile_element * const element)
  *
  *  rct2: 0x0068BB18
  */
-void map_obstruction_set_error_text(rct_tile_element *mapElement)
+void map_obstruction_set_error_text(rct_tile_element *tileElement)
 {
     rct_string_id errorStringId;
     Ride *ride;
     rct_scenery_entry *sceneryEntry;
 
     errorStringId = STR_OBJECT_IN_THE_WAY;
-    switch (tile_element_get_type(mapElement)) {
+    switch (tile_element_get_type(tileElement)) {
     case TILE_ELEMENT_TYPE_SURFACE:
         errorStringId = STR_RAISE_OR_LOWER_LAND_FIRST;
         break;
@@ -3226,18 +3226,18 @@ void map_obstruction_set_error_text(rct_tile_element *mapElement)
         errorStringId = STR_FOOTPATH_IN_THE_WAY;
         break;
     case TILE_ELEMENT_TYPE_TRACK:
-        ride = get_ride(mapElement->properties.track.ride_index);
+        ride = get_ride(tileElement->properties.track.ride_index);
         errorStringId = STR_X_IN_THE_WAY;
         set_format_arg(0, rct_string_id, ride->name);
         set_format_arg(2, uint32, ride->name_arguments);
         break;
     case TILE_ELEMENT_TYPE_SCENERY:
-        sceneryEntry = get_small_scenery_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_small_scenery_entry(tileElement->properties.scenery.type);
         errorStringId = STR_X_IN_THE_WAY;
         set_format_arg(0, rct_string_id, sceneryEntry->name);
         break;
     case TILE_ELEMENT_TYPE_ENTRANCE:
-        switch (mapElement->properties.entrance.type) {
+        switch (tileElement->properties.entrance.type) {
         case ENTRANCE_TYPE_RIDE_ENTRANCE:
             errorStringId = STR_RIDE_ENTRANCE_IN_THE_WAY;
             break;
@@ -3250,12 +3250,12 @@ void map_obstruction_set_error_text(rct_tile_element *mapElement)
         }
         break;
     case TILE_ELEMENT_TYPE_WALL:
-        sceneryEntry = get_wall_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
         errorStringId = STR_X_IN_THE_WAY;
         set_format_arg(0, rct_string_id, sceneryEntry->name);
         break;
     case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
-        sceneryEntry = get_large_scenery_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_large_scenery_entry(tileElement->properties.scenery.type);
         errorStringId = STR_X_IN_THE_WAY;
         set_format_arg(0, rct_string_id, sceneryEntry->name);
         break;
@@ -3405,9 +3405,9 @@ void map_update_tiles()
             interleaved_xy >>= 1;
         }
 
-        rct_tile_element *mapElement = map_get_surface_element_at(x, y);
-        if (mapElement != NULL) {
-            map_update_grass_length(x * 32, y * 32, mapElement);
+        rct_tile_element *tileElement = map_get_surface_element_at(x, y);
+        if (tileElement != NULL) {
+            map_update_grass_length(x * 32, y * 32, tileElement);
             scenery_update_tile(x * 32, y * 32);
         }
 
@@ -3420,19 +3420,19 @@ void map_update_tiles()
  *
  *  rct2: 0x006647A1
  */
-static void map_update_grass_length(sint32 x, sint32 y, rct_tile_element *mapElement)
+static void map_update_grass_length(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
     // Check if tile is grass
-    if ((mapElement->properties.surface.terrain & 0xE0) && !(mapElement->type & 3))
+    if ((tileElement->properties.surface.terrain & 0xE0) && !(tileElement->type & 3))
         return;
 
-    sint32 grassLength = mapElement->properties.surface.grass_length & 7;
+    sint32 grassLength = tileElement->properties.surface.grass_length & 7;
 
     // Check if grass is underwater or outside park
-    sint32 waterHeight = map_get_water_height(mapElement) * 2;
-    if (waterHeight > mapElement->base_height || !map_is_location_in_park(x, y)) {
+    sint32 waterHeight = map_get_water_height(tileElement) * 2;
+    if (waterHeight > tileElement->base_height || !map_is_location_in_park(x, y)) {
         if (grassLength != GRASS_LENGTH_CLEAR_0)
-            map_set_grass_length(x, y, mapElement, GRASS_LENGTH_CLEAR_0);
+            map_set_grass_length(x, y, tileElement, GRASS_LENGTH_CLEAR_0);
 
         return;
     }
@@ -3440,59 +3440,59 @@ static void map_update_grass_length(sint32 x, sint32 y, rct_tile_element *mapEle
     // Grass can't grow any further than CLUMPS_2 but this code also cuts grass
     // if there is an object placed on top of it.
 
-    sint32 z0 = mapElement->base_height;
-    sint32 z1 = mapElement->base_height + 2;
-    if (mapElement->properties.surface.slope & 0x10)
+    sint32 z0 = tileElement->base_height;
+    sint32 z1 = tileElement->base_height + 2;
+    if (tileElement->properties.surface.slope & 0x10)
         z1 += 2;
 
     // Check objects above grass
-    rct_tile_element *mapElementAbove = mapElement;
+    rct_tile_element *tileElementAbove = tileElement;
     for (;;) {
-        if (mapElementAbove->flags & TILE_ELEMENT_FLAG_LAST_TILE) {
+        if (tileElementAbove->flags & TILE_ELEMENT_FLAG_LAST_TILE) {
             // Grow grass
 
             // Check interim grass lengths
-            uint8 lengthNibble = (mapElement->properties.surface.grass_length & 0xF0) >> 4;
+            uint8 lengthNibble = (tileElement->properties.surface.grass_length & 0xF0) >> 4;
             if (lengthNibble < 0xF) {
-                mapElement->properties.surface.grass_length += 0x10;
+                tileElement->properties.surface.grass_length += 0x10;
             } else {
                 // Zeros the length nibble
-                mapElement->properties.surface.grass_length += 0x10;
-                mapElement->properties.surface.grass_length ^= 8;
-                if (mapElement->properties.surface.grass_length & 8) {
+                tileElement->properties.surface.grass_length += 0x10;
+                tileElement->properties.surface.grass_length ^= 8;
+                if (tileElement->properties.surface.grass_length & 8) {
                     // Random growth rate (length nibble)
-                    mapElement->properties.surface.grass_length |= scenario_rand() & 0x70;
+                    tileElement->properties.surface.grass_length |= scenario_rand() & 0x70;
                 } else {
                     // Increase length if not at max length
                     if (grassLength != GRASS_LENGTH_CLUMPS_2)
-                        map_set_grass_length(x, y, mapElement, grassLength + 1);
+                        map_set_grass_length(x, y, tileElement, grassLength + 1);
                 }
             }
         } else {
-            mapElementAbove++;
-            if (tile_element_get_type(mapElementAbove) == TILE_ELEMENT_TYPE_WALL)
+            tileElementAbove++;
+            if (tile_element_get_type(tileElementAbove) == TILE_ELEMENT_TYPE_WALL)
                 continue;
             // Grass should not be affected by ghost elements.
-            if (tile_element_is_ghost(mapElementAbove))
+            if (tile_element_is_ghost(tileElementAbove))
                 continue;
-            if (z0 >= mapElementAbove->clearance_height)
+            if (z0 >= tileElementAbove->clearance_height)
                 continue;
-            if (z1 < mapElementAbove->base_height)
+            if (z1 < tileElementAbove->base_height)
                 continue;
 
             if (grassLength != GRASS_LENGTH_CLEAR_0)
-                map_set_grass_length(x, y, mapElement, GRASS_LENGTH_CLEAR_0);
+                map_set_grass_length(x, y, tileElement, GRASS_LENGTH_CLEAR_0);
         }
         break;
     }
 }
 
-static void map_set_grass_length(sint32 x, sint32 y, rct_tile_element *mapElement, sint32 length)
+static void map_set_grass_length(sint32 x, sint32 y, rct_tile_element *tileElement, sint32 length)
 {
     sint32 z0, z1;
 
-    mapElement->properties.surface.grass_length = length;
-    z0 = mapElement->base_height * 8;
+    tileElement->properties.surface.grass_length = length;
+    z0 = tileElement->base_height * 8;
     z1 = z0 + 16;
     map_invalidate_tile(x, y, z0, z1);
 }
@@ -3529,36 +3529,36 @@ void map_restore_provisional_elements()
     }
 }
 
-sint32 tile_element_get_banner_index(rct_tile_element *mapElement)
+sint32 tile_element_get_banner_index(rct_tile_element *tileElement)
 {
     rct_scenery_entry* sceneryEntry;
 
-    switch (tile_element_get_type(mapElement)) {
+    switch (tile_element_get_type(tileElement)) {
     case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
-        sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
+        sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
         if (sceneryEntry->large_scenery.scrolling_mode == 0xFF)
             return -1;
 
         return
-            (mapElement->type & TILE_ELEMENT_QUADRANT_MASK) |
-            ((mapElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) |
-            ((mapElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
+            (tileElement->type & TILE_ELEMENT_QUADRANT_MASK) |
+            ((tileElement->properties.scenerymultiple.colour[0] & 0xE0) >> 2) |
+            ((tileElement->properties.scenerymultiple.colour[1] & 0xE0) >> 5);
     case TILE_ELEMENT_TYPE_WALL:
-        sceneryEntry = get_wall_entry(mapElement->properties.wall.type);
+        sceneryEntry = get_wall_entry(tileElement->properties.wall.type);
         if (sceneryEntry == NULL || sceneryEntry->wall.scrolling_mode == 0xFF)
             return -1;
 
-        return mapElement->properties.wall.banner_index;
+        return tileElement->properties.wall.banner_index;
     case TILE_ELEMENT_TYPE_BANNER:
-        return mapElement->properties.banner.index;
+        return tileElement->properties.banner.index;
     default:
         return -1;
     }
 }
 
-void tile_element_remove_banner_entry(rct_tile_element *mapElement)
+void tile_element_remove_banner_entry(rct_tile_element *tileElement)
 {
-    sint32 bannerIndex = tile_element_get_banner_index(mapElement);
+    sint32 bannerIndex = tile_element_get_banner_index(tileElement);
     if (bannerIndex == -1)
         return;
 
@@ -3594,30 +3594,30 @@ void map_remove_out_of_range_elements()
  */
 void map_extend_boundary_surface()
 {
-    rct_tile_element *existingMapElement, *newMapElement;
+    rct_tile_element *existingTileElement, *newTileElement;
     sint32 x, y, z, slope;
 
     y = gMapSize - 2;
     for (x = 0; x < MAXIMUM_MAP_SIZE_TECHNICAL; x++) {
-        existingMapElement = map_get_surface_element_at(x, y - 1);
-        newMapElement = map_get_surface_element_at(x, y);
+        existingTileElement = map_get_surface_element_at(x, y - 1);
+        newTileElement = map_get_surface_element_at(x, y);
 
-        newMapElement->type = (newMapElement->type & 0x7C) | (existingMapElement->type & 0x83);
-        newMapElement->properties.surface.slope = existingMapElement->properties.surface.slope & 0xE0;
-        newMapElement->properties.surface.terrain = existingMapElement->properties.surface.terrain;
-        newMapElement->properties.surface.grass_length = existingMapElement->properties.surface.grass_length;
-        newMapElement->properties.surface.ownership = 0;
+        newTileElement->type = (newTileElement->type & 0x7C) | (existingTileElement->type & 0x83);
+        newTileElement->properties.surface.slope = existingTileElement->properties.surface.slope & 0xE0;
+        newTileElement->properties.surface.terrain = existingTileElement->properties.surface.terrain;
+        newTileElement->properties.surface.grass_length = existingTileElement->properties.surface.grass_length;
+        newTileElement->properties.surface.ownership = 0;
 
-        z = existingMapElement->base_height;
-        slope = existingMapElement->properties.surface.slope & 9;
+        z = existingTileElement->base_height;
+        slope = existingTileElement->properties.surface.slope & 9;
         if (slope == 9) {
             z += 2;
             slope = 0;
-            if (existingMapElement->properties.surface.slope & 0x10) {
+            if (existingTileElement->properties.surface.slope & 0x10) {
                 slope = 1;
-                if (existingMapElement->properties.surface.slope & 0x04) {
+                if (existingTileElement->properties.surface.slope & 0x04) {
                     slope = 8;
-                    if (existingMapElement->properties.surface.slope & 0x02) {
+                    if (existingTileElement->properties.surface.slope & 0x02) {
                         slope = 0;
                     }
                 }
@@ -3626,34 +3626,34 @@ void map_extend_boundary_surface()
         if (slope & 1) slope |= 2;
         if (slope & 8) slope |= 4;
 
-        newMapElement->properties.surface.slope |= slope;
-        newMapElement->base_height = z;
-        newMapElement->clearance_height = z;
+        newTileElement->properties.surface.slope |= slope;
+        newTileElement->base_height = z;
+        newTileElement->clearance_height = z;
 
         update_park_fences(x << 5, y << 5);
     }
 
     x = gMapSize - 2;
     for (y = 0; y < MAXIMUM_MAP_SIZE_TECHNICAL; y++) {
-        existingMapElement = map_get_surface_element_at(x - 1, y);
-        newMapElement = map_get_surface_element_at(x, y);
+        existingTileElement = map_get_surface_element_at(x - 1, y);
+        newTileElement = map_get_surface_element_at(x, y);
 
-        newMapElement->type = (newMapElement->type & 0x7C) | (existingMapElement->type & 0x83);
-        newMapElement->properties.surface.slope = existingMapElement->properties.surface.slope & 0xE0;
-        newMapElement->properties.surface.terrain = existingMapElement->properties.surface.terrain;
-        newMapElement->properties.surface.grass_length = existingMapElement->properties.surface.grass_length;
-        newMapElement->properties.surface.ownership = 0;
+        newTileElement->type = (newTileElement->type & 0x7C) | (existingTileElement->type & 0x83);
+        newTileElement->properties.surface.slope = existingTileElement->properties.surface.slope & 0xE0;
+        newTileElement->properties.surface.terrain = existingTileElement->properties.surface.terrain;
+        newTileElement->properties.surface.grass_length = existingTileElement->properties.surface.grass_length;
+        newTileElement->properties.surface.ownership = 0;
 
-        z = existingMapElement->base_height;
-        slope = existingMapElement->properties.surface.slope & 3;
+        z = existingTileElement->base_height;
+        slope = existingTileElement->properties.surface.slope & 3;
         if (slope == 3) {
             z += 2;
             slope = 0;
-            if (existingMapElement->properties.surface.slope & 0x10) {
+            if (existingTileElement->properties.surface.slope & 0x10) {
                 slope = 1;
-                if (existingMapElement->properties.surface.slope & 0x04) {
+                if (existingTileElement->properties.surface.slope & 0x04) {
                     slope = 2;
-                    if (existingMapElement->properties.surface.slope & 0x08) {
+                    if (existingTileElement->properties.surface.slope & 0x08) {
                         slope = 0;
                     }
                 }
@@ -3662,9 +3662,9 @@ void map_extend_boundary_surface()
         if (slope & 1) slope |= 8;
         if (slope & 2) slope |= 4;
 
-        newMapElement->properties.surface.slope |= slope;
-        newMapElement->base_height = z;
-        newMapElement->clearance_height = z;
+        newTileElement->properties.surface.slope |= slope;
+        newTileElement->base_height = z;
+        newTileElement->clearance_height = z;
 
         update_park_fences(x << 5, y << 5);
     }
@@ -3748,153 +3748,153 @@ static void clear_elements_at(sint32 x, sint32 y)
         }
     }
 
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
 
     // Remove all elements except the last one
-    while(!tile_element_is_last_for_tile(mapElement))
-        clear_element_at(x, y, &mapElement);
+    while(!tile_element_is_last_for_tile(tileElement))
+        clear_element_at(x, y, &tileElement);
 
     // Remove the last element
-    clear_element_at(x, y, &mapElement);
+    clear_element_at(x, y, &tileElement);
 }
 
 sint32 map_get_highest_z(sint32 tileX, sint32 tileY)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     sint32 z;
 
-    mapElement = map_get_surface_element_at(tileX, tileY);
-    if (mapElement == NULL)
+    tileElement = map_get_surface_element_at(tileX, tileY);
+    if (tileElement == NULL)
         return -1;
 
-    z = mapElement->base_height * 8;
+    z = tileElement->base_height * 8;
 
     // Raise z so that is above highest point of land and water on tile
-    if ((mapElement->properties.surface.slope & 0x0F) != 0)
+    if ((tileElement->properties.surface.slope & 0x0F) != 0)
         z += 16;
-    if ((mapElement->properties.surface.slope & 0x10) != 0)
+    if ((tileElement->properties.surface.slope & 0x10) != 0)
         z += 16;
 
-    z = max(z, map_get_water_height(mapElement) * 16);
+    z = max(z, map_get_water_height(tileElement) * 16);
     return z;
 }
 
-bool tile_element_is_underground(rct_tile_element *mapElement)
+bool tile_element_is_underground(rct_tile_element *tileElement)
 {
     do {
-        mapElement++;
-        if (tile_element_is_last_for_tile(mapElement - 1))
+        tileElement++;
+        if (tile_element_is_last_for_tile(tileElement - 1))
             return false;
-    } while (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SURFACE);
+    } while (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SURFACE);
     return true;
 }
 
 rct_tile_element *map_get_large_scenery_segment(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 sequence)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
-    if (mapElement == NULL)
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
+    if (tileElement == NULL)
     {
         return NULL;
     }
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
-        if ((mapElement->properties.scenerymultiple.type >> 10) != sequence)
+        if ((tileElement->properties.scenerymultiple.type >> 10) != sequence)
             continue;
-        if ((tile_element_get_direction(mapElement)) != direction)
+        if ((tile_element_get_direction(tileElement)) != direction)
             continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return NULL;
 }
 
 rct_tile_element *map_get_park_entrance_element_at(sint32 x, sint32 y, sint32 z, bool ghost)
 {
-    rct_tile_element* mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element* tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
 
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
 
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
             continue;
 
-        if ((ghost == false) && (mapElement->flags & TILE_ELEMENT_FLAG_GHOST))
+        if ((ghost == false) && (tileElement->flags & TILE_ELEMENT_FLAG_GHOST))
             continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return NULL;
 }
 
 rct_tile_element * map_get_ride_entrance_element_at(sint32 x, sint32 y, sint32 z, bool ghost)
 {
-    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
 
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
 
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
             continue;
 
-        if ((ghost == false) && (mapElement->flags & TILE_ELEMENT_FLAG_GHOST))
+        if ((ghost == false) && (tileElement->flags & TILE_ELEMENT_FLAG_GHOST))
             continue;
 
-        return mapElement;
+        return tileElement;
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
 
 rct_tile_element * map_get_ride_exit_element_at(sint32 x, sint32 y, sint32 z, bool ghost)
 {
-    rct_tile_element * mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
 
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
 
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT)
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT)
             continue;
 
-        if ((ghost == false) && (mapElement->flags & TILE_ELEMENT_FLAG_GHOST))
+        if ((ghost == false) && (tileElement->flags & TILE_ELEMENT_FLAG_GHOST))
             continue;
 
-        return mapElement;
+        return tileElement;
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
 
 rct_tile_element *map_get_small_scenery_element_at(sint32 x, sint32 y, sint32 z, sint32 type, uint8 quadrant)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
             continue;
-        if (mapElement->type >> 6 != quadrant)
+        if (tileElement->type >> 6 != quadrant)
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
-        if (mapElement->properties.scenery.type != type)
+        if (tileElement->properties.scenery.type != type)
             continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return NULL;
 }
 
@@ -3902,16 +3902,16 @@ bool map_large_scenery_get_origin(
     sint32 x, sint32 y, sint32 z, sint32 direction, sint32 sequence,
     sint32 *outX, sint32 *outY, sint32 *outZ, rct_tile_element** outElement
 ) {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_scenery_entry *sceneryEntry;
     rct_large_scenery_tile *tile;
     sint16 offsetX, offsetY;
 
-    mapElement = map_get_large_scenery_segment(x, y, z, direction, sequence);
-    if (mapElement == NULL)
+    tileElement = map_get_large_scenery_segment(x, y, z, direction, sequence);
+    if (tileElement == NULL)
         return false;
 
-    sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
+    sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
     tile = &sceneryEntry->large_scenery.tiles[sequence];
 
     offsetX = tile->x_offset;
@@ -3922,7 +3922,7 @@ bool map_large_scenery_get_origin(
     *outY = y - offsetY;
     *outZ = (z * 8) - tile->z_offset;
     if (outElement != NULL)
-        *outElement = mapElement;
+        *outElement = tileElement;
     return true;
 }
 
@@ -3932,17 +3932,17 @@ bool map_large_scenery_get_origin(
  */
 bool sign_set_colour(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 sequence, uint8 mainColour, uint8 textColour)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_scenery_entry *sceneryEntry;
     rct_large_scenery_tile *sceneryTiles, *tile;
     sint16 offsetX, offsetY;
     sint32 x0, y0, z0;
 
-    if (!map_large_scenery_get_origin(x, y, z, direction, sequence, &x0, &y0, &z0, &mapElement)) {
+    if (!map_large_scenery_get_origin(x, y, z, direction, sequence, &x0, &y0, &z0, &tileElement)) {
         return false;
     }
 
-    sceneryEntry = get_large_scenery_entry(mapElement->properties.scenerymultiple.type & 0x3FF);
+    sceneryEntry = get_large_scenery_entry(tileElement->properties.scenerymultiple.type & 0x3FF);
     sceneryTiles = sceneryEntry->large_scenery.tiles;
 
     // Iterate through each tile of the large scenery element
@@ -3955,14 +3955,14 @@ bool sign_set_colour(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 sequ
         x = x0 + offsetX;
         y = y0 + offsetY;
         z = (z0 + tile->z_offset) / 8;
-        mapElement = map_get_large_scenery_segment(x, y, z, direction, sequence);
-        if (mapElement != NULL) {
-            mapElement->properties.scenerymultiple.colour[0] &= 0xE0;
-            mapElement->properties.scenerymultiple.colour[1] &= 0xE0;
-            mapElement->properties.scenerymultiple.colour[0] |= mainColour;
-            mapElement->properties.scenerymultiple.colour[1] |= textColour;
+        tileElement = map_get_large_scenery_segment(x, y, z, direction, sequence);
+        if (tileElement != NULL) {
+            tileElement->properties.scenerymultiple.colour[0] &= 0xE0;
+            tileElement->properties.scenerymultiple.colour[1] &= 0xE0;
+            tileElement->properties.scenerymultiple.colour[0] |= mainColour;
+            tileElement->properties.scenerymultiple.colour[1] |= textColour;
 
-            map_invalidate_tile(x, y, mapElement->base_height * 8 , mapElement->clearance_height * 8);
+            map_invalidate_tile(x, y, tileElement->base_height * 8 , tileElement->clearance_height * 8);
         }
     }
 
@@ -4082,9 +4082,9 @@ void map_invalidate_tile_full(sint32 x, sint32 y)
     map_invalidate_tile(x, y, 0, 2080);
 }
 
-void map_invalidate_element(sint32 x, sint32 y, rct_tile_element *mapElement)
+void map_invalidate_element(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    map_invalidate_tile(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+    map_invalidate_tile(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
 }
 
 sint32 map_get_tile_side(sint32 mapX, sint32 mapY)
@@ -4110,41 +4110,41 @@ sint32 map_get_tile_quadrant(sint32 mapX, sint32 mapY)
  *  rct2: 0x00693BFF
  */
 bool map_surface_is_blocked(sint16 x, sint16 y){
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     if (x >= 8192 || y >= 8192)
         return true;
 
-    mapElement = map_get_surface_element_at(x / 32, y / 32);
+    tileElement = map_get_surface_element_at(x / 32, y / 32);
 
-    if (mapElement == NULL) {
+    if (tileElement == NULL) {
         return true;
     }
 
-    sint16 water_height = map_get_water_height(mapElement);
+    sint16 water_height = map_get_water_height(tileElement);
     water_height *= 2;
-    if (water_height > mapElement->base_height)
+    if (water_height > tileElement->base_height)
         return true;
 
-    sint16 base_z = mapElement->base_height;
-    sint16 clear_z = mapElement->base_height + 2;
-    if (mapElement->properties.surface.slope & (1 << 4))
+    sint16 base_z = tileElement->base_height;
+    sint16 clear_z = tileElement->base_height + 2;
+    if (tileElement->properties.surface.slope & (1 << 4))
         clear_z += 2;
 
-    while (!tile_element_is_last_for_tile(mapElement++)){
-        if (clear_z >= mapElement->clearance_height)
+    while (!tile_element_is_last_for_tile(tileElement++)){
+        if (clear_z >= tileElement->clearance_height)
             continue;
 
-        if (base_z < mapElement->base_height)
+        if (base_z < tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH ||
-            tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH ||
+            tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
             continue;
 
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
             return true;
 
-        rct_scenery_entry* scenery = get_small_scenery_entry(mapElement->properties.scenery.type);
+        rct_scenery_entry* scenery = get_small_scenery_entry(tileElement->properties.scenery.type);
         if (scenery == NULL)
         {
             return false;
@@ -4279,8 +4279,8 @@ void game_command_set_sign_style(sint32* eax, sint32* ebx, sint32* ecx, sint32*
 
         map_invalidate_tile(x, y, tile_element->base_height * 8, tile_element->clearance_height * 8);
     } else { // large sign
-        rct_tile_element *mapElement = banner_get_tile_element(bannerId);
-        if (mapElement == NULL || tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE) {
+        rct_tile_element *tileElement = banner_get_tile_element(bannerId);
+        if (tileElement == NULL || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE) {
             gGameCommandErrorText = STR_ERR_CANT_SET_BANNER_TEXT;
             *ebx = MONEY32_UNDEFINED;
             return;
@@ -4294,9 +4294,9 @@ void game_command_set_sign_style(sint32* eax, sint32* ebx, sint32* ecx, sint32*
         if (!sign_set_colour(
             banner->x * 32,
             banner->y * 32,
-            mapElement->base_height,
-            tile_element_get_direction(mapElement),
-            mapElement->properties.scenerymultiple.type >> 10,
+            tileElement->base_height,
+            tile_element_get_direction(tileElement),
+            tileElement->properties.scenerymultiple.type >> 10,
             mainColour,
             textColour
         )) {
@@ -4475,13 +4475,13 @@ void game_command_modify_tile(sint32* eax, sint32* ebx, sint32* ecx, sint32* edx
  */
 rct_tile_element *map_get_track_element_at(sint32 x, sint32 y, sint32 z)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-        if (mapElement->base_height != z) continue;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->base_height != z) continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
@@ -4495,14 +4495,14 @@ rct_tile_element *map_get_track_element_at(sint32 x, sint32 y, sint32 z)
  */
 rct_tile_element *map_get_track_element_at_of_type(sint32 x, sint32 y, sint32 z, sint32 trackType)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-        if (mapElement->base_height != z) continue;
-        if (mapElement->properties.track.type != trackType) continue;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->base_height != z) continue;
+        if (tileElement->properties.track.type != trackType) continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
@@ -4517,16 +4517,16 @@ rct_tile_element *map_get_track_element_at_of_type(sint32 x, sint32 y, sint32 z,
  */
 rct_tile_element *map_get_track_element_at_of_type_seq(sint32 x, sint32 y, sint32 z, sint32 trackType, sint32 sequence)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement == NULL) break;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-        if (mapElement->base_height != z) continue;
-        if (mapElement->properties.track.type != trackType) continue;
-        if (tile_element_get_track_sequence(mapElement) != sequence) continue;
+        if (tileElement == NULL) break;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->base_height != z) continue;
+        if (tileElement->properties.track.type != trackType) continue;
+        if (tile_element_get_track_sequence(tileElement) != sequence) continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 }
@@ -4540,15 +4540,15 @@ rct_tile_element *map_get_track_element_at_of_type_seq(sint32 x, sint32 y, sint3
  * @param ride index
  */
 rct_tile_element *map_get_track_element_at_of_type_from_ride(sint32 x, sint32 y, sint32 z, sint32 trackType, sint32 rideIndex) {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-        if (mapElement->base_height != z) continue;
-        if (mapElement->properties.track.ride_index != rideIndex) continue;
-        if (mapElement->properties.track.type != trackType) continue;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->base_height != z) continue;
+        if (tileElement->properties.track.ride_index != rideIndex) continue;
+        if (tileElement->properties.track.type != trackType) continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 };
@@ -4561,14 +4561,14 @@ rct_tile_element *map_get_track_element_at_of_type_from_ride(sint32 x, sint32 y,
  * @param ride index
  */
 rct_tile_element *map_get_track_element_at_from_ride(sint32 x, sint32 y, sint32 z, sint32 rideIndex) {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-        if (mapElement->base_height != z) continue;
-        if (mapElement->properties.track.ride_index != rideIndex) continue;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->base_height != z) continue;
+        if (tileElement->properties.track.ride_index != rideIndex) continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 };
@@ -4583,15 +4583,15 @@ rct_tile_element *map_get_track_element_at_from_ride(sint32 x, sint32 y, sint32
  */
 rct_tile_element *map_get_track_element_at_with_direction_from_ride(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 rideIndex)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK) continue;
-        if (mapElement->base_height != z) continue;
-        if (mapElement->properties.track.ride_index != rideIndex) continue;
-        if (tile_element_get_direction(mapElement) != direction) continue;
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->base_height != z) continue;
+        if (tileElement->properties.track.ride_index != rideIndex) continue;
+        if (tile_element_get_direction(tileElement) != direction) continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return NULL;
 };
@@ -4620,17 +4620,17 @@ void map_offset_with_rotation(sint16 *x, sint16 *y, sint16 offsetX, sint16 offse
 
 rct_tile_element *map_get_wall_element_at(sint32 x, sint32 y, sint32 z, sint32 direction)
 {
-    rct_tile_element *mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
             continue;
-        if (mapElement->base_height != z)
+        if (tileElement->base_height != z)
             continue;
-        if (tile_element_get_direction(mapElement) != direction)
+        if (tile_element_get_direction(tileElement) != direction)
             continue;
 
-        return mapElement;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+        return tileElement;
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return NULL;
 }
 
@@ -4647,32 +4647,32 @@ uint32 map_get_available_peep_spawn_index_list(uint32* peepSpawnIndexList)
 
 uint16 check_max_allowable_land_rights_for_tile(uint8 x, uint8 y, uint8 base_z)
 {
-    rct_tile_element * mapElement = map_get_first_element_at(x, y);
+    rct_tile_element * tileElement = map_get_first_element_at(x, y);
     uint16 destOwnership = OWNERSHIP_OWNED;
 
     // Sometimes done deliberately.
-    if (mapElement == NULL)
+    if (tileElement == NULL)
     {
         return OWNERSHIP_OWNED;
     }
 
     do
     {
-        sint32 type = tile_element_get_type(mapElement);
+        sint32 type = tile_element_get_type(tileElement);
         if (type == TILE_ELEMENT_TYPE_PATH ||
-            (type == TILE_ELEMENT_TYPE_ENTRANCE && mapElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE))
+            (type == TILE_ELEMENT_TYPE_ENTRANCE && tileElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE))
         {
             destOwnership = OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED;
             // Do not own construction rights if too high/below surface
-            if (mapElement->base_height - 3 > base_z ||
-                mapElement->base_height < base_z)
+            if (tileElement->base_height - 3 > base_z ||
+                tileElement->base_height < base_z)
             {
                 destOwnership = OWNERSHIP_UNOWNED;
                 break;
             }
         }
     }
-    while (!tile_element_is_last_for_tile(mapElement++));
+    while (!tile_element_is_last_for_tile(tileElement++));
 
     return destOwnership;
 }
diff --git a/src/openrct2/world/map.h b/src/openrct2/world/map.h
index 7b75f75376..a35dda29cb 100644
--- a/src/openrct2/world/map.h
+++ b/src/openrct2/world/map.h
@@ -362,18 +362,18 @@ extern uint8        gMapSelectArrowDirection;
 extern uint8 gMapGroundFlags;
 
 #ifdef NO_RCT2
-extern rct_tile_element gMapElements[];
-extern rct_tile_element *gMapElementTilePointers[];
+extern rct_tile_element gTileElements[];
+extern rct_tile_element *gTileElementTilePointers[];
 #else
-extern rct_tile_element *gMapElements;
-extern rct_tile_element **gMapElementTilePointers;
+extern rct_tile_element *gTileElements;
+extern rct_tile_element **gTileElementTilePointers;
 #endif
 
 extern LocationXY16 gMapSelectionTiles[300];
 extern rct2_peep_spawn gPeepSpawns[MAX_PEEP_SPAWNS];
 
-extern rct_tile_element *gNextFreeMapElement;
-extern uint32 gNextFreeMapElementPointerIndex;
+extern rct_tile_element *gNextFreeTileElement;
+extern uint32 gNextFreeTileElementPointerIndex;
 
 // Used in the land tool window to enable mountain tool / land smoothing
 extern bool gLandMountainMode;
@@ -429,18 +429,18 @@ bool map_is_location_owned(sint32 x, sint32 y, sint32 z);
 bool map_is_location_in_park(sint32 x, sint32 y);
 bool map_is_location_owned_or_has_rights(sint32 x, sint32 y);
 bool map_surface_is_blocked(sint16 x, sint16 y);
-sint32 tile_element_get_station(const rct_tile_element * mapElement);
-void tile_element_set_station(rct_tile_element * mapElement, uint32 stationIndex);
-sint32 tile_element_get_track_sequence(const rct_tile_element * mapElement);
-void tile_element_set_track_sequence(rct_tile_element * mapElement, sint32 trackSequence);
-bool tile_element_get_green_light(const rct_tile_element * mapElement);
-void tile_element_set_green_light(rct_tile_element * mapElement, bool greenLight);
-sint32 tile_element_get_brake_booster_speed(const rct_tile_element *mapElement);
-void tile_element_set_brake_booster_speed(rct_tile_element *mapElement, sint32 speed);
-bool tile_element_is_taking_photo(const rct_tile_element * mapElement);
-void tile_element_set_onride_photo_timeout(rct_tile_element * mapElement);
-void tile_element_decrement_onride_photo_timout(rct_tile_element * mapElement);
-void tile_element_remove(rct_tile_element *mapElement);
+sint32 tile_element_get_station(const rct_tile_element * tileElement);
+void tile_element_set_station(rct_tile_element * tileElement, uint32 stationIndex);
+sint32 tile_element_get_track_sequence(const rct_tile_element * tileElement);
+void tile_element_set_track_sequence(rct_tile_element * tileElement, sint32 trackSequence);
+bool tile_element_get_green_light(const rct_tile_element * tileElement);
+void tile_element_set_green_light(rct_tile_element * tileElement, bool greenLight);
+sint32 tile_element_get_brake_booster_speed(const rct_tile_element *tileElement);
+void tile_element_set_brake_booster_speed(rct_tile_element *tileElement, sint32 speed);
+bool tile_element_is_taking_photo(const rct_tile_element * tileElement);
+void tile_element_set_onride_photo_timeout(rct_tile_element * tileElement);
+void tile_element_decrement_onride_photo_timout(rct_tile_element * tileElement);
+void tile_element_remove(rct_tile_element *tileElement);
 void map_remove_all_rides();
 void map_invalidate_map_selection_tiles();
 void map_invalidate_selection_rect();
@@ -457,7 +457,7 @@ sint32 map_can_construct_at(sint32 x, sint32 y, sint32 zLow, sint32 zHigh, uint8
 void rotate_map_coordinates(sint16 *x, sint16 *y, sint32 rotation);
 LocationXY16 coordinate_3d_to_2d(const LocationXYZ16* coordinate_3d, sint32 rotation);
 money32 map_clear_scenery(sint32 x0, sint32 y0, sint32 x1, sint32 y1, sint32 clear, sint32 flags);
-sint32 map_get_water_height(const rct_tile_element * mapElement);
+sint32 map_get_water_height(const rct_tile_element * tileElement);
 money32 lower_water(sint16 x0, sint16 y0, sint16 x1, sint16 y1, uint8 flags);
 money32 raise_water(sint16 x0, sint16 y0, sint16 x1, sint16 y1, uint8 flags);
 money32 wall_place(sint32 type, sint32 x, sint32 y, sint32 z, sint32 edge, sint32 primaryColour, sint32 secondaryColour, sint32 tertiaryColour, sint32 flags);
@@ -508,10 +508,10 @@ void wall_remove_intersecting_walls(sint32 x, sint32 y, sint32 z0, sint32 z1, si
 void map_update_tiles();
 sint32 map_get_highest_z(sint32 tileX, sint32 tileY);
 
-sint32 tile_element_get_banner_index(rct_tile_element *mapElement);
-void tile_element_remove_banner_entry(rct_tile_element *mapElement);
+sint32 tile_element_get_banner_index(rct_tile_element *tileElement);
+void tile_element_remove_banner_entry(rct_tile_element *tileElement);
 
-bool tile_element_is_underground(rct_tile_element *mapElement);
+bool tile_element_is_underground(rct_tile_element *tileElement);
 
 void map_remove_out_of_range_elements();
 void map_extend_boundary_surface();
@@ -524,7 +524,7 @@ void map_invalidate_tile(sint32 x, sint32 y, sint32 z0, sint32 z1);
 void map_invalidate_tile_zoom1(sint32 x, sint32 y, sint32 z0, sint32 z1);
 void map_invalidate_tile_zoom0(sint32 x, sint32 y, sint32 z0, sint32 z1);
 void map_invalidate_tile_full(sint32 x, sint32 y);
-void map_invalidate_element(sint32 x, sint32 y, rct_tile_element *mapElement);
+void map_invalidate_element(sint32 x, sint32 y, rct_tile_element *tileElement);
 
 sint32 map_get_tile_side(sint32 mapX, sint32 mapY);
 sint32 map_get_tile_quadrant(sint32 mapX, sint32 mapY);
@@ -548,7 +548,7 @@ rct_tile_element *map_get_track_element_at_from_ride(sint32 x, sint32 y, sint32
 rct_tile_element *map_get_track_element_at_with_direction_from_ride(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 rideIndex);
 
 bool map_is_location_at_edge(sint32 x, sint32 y);
-void map_obstruction_set_error_text(rct_tile_element *mapElement);
+void map_obstruction_set_error_text(rct_tile_element *tileElement);
 uint8 wall_element_get_animation_frame(rct_tile_element *fenceElement);
 void wall_element_set_animation_frame(rct_tile_element * wallElement, uint8 frameNum);
 uint8 wall_element_get_secondary_colour(rct_tile_element * wallElement);
diff --git a/src/openrct2/world/map_animation.c b/src/openrct2/world/map_animation.c
index 35a2613a23..140804d9ff 100644
--- a/src/openrct2/world/map_animation.c
+++ b/src/openrct2/world/map_animation.c
@@ -109,26 +109,26 @@ static bool map_animation_invalidate(rct_map_animation *obj)
  */
 static bool map_animation_invalidate_ride_entrance(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     Ride *ride;
     const rct_ride_entrance_definition *entranceDefinition;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
             continue;
 
-        ride = get_ride(mapElement->properties.entrance.ride_index);
+        ride = get_ride(tileElement->properties.entrance.ride_index);
         entranceDefinition = &RideEntranceDefinitions[ride->entrance_style];
 
-        sint32 height = (mapElement->base_height * 8) + entranceDefinition->height + 8;
+        sint32 height = (tileElement->base_height * 8) + entranceDefinition->height + 8;
         map_invalidate_tile_zoom1(x, y, height, height + 16);
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -139,26 +139,26 @@ static bool map_animation_invalidate_ride_entrance(sint32 x, sint32 y, sint32 ba
  */
 static bool map_animation_invalidate_queue_banner(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
-        if (!(mapElement->flags & 1))
+        if (!(tileElement->flags & 1))
             continue;
-        if (!(mapElement->properties.path.type & PATH_FLAG_QUEUE_BANNER))
+        if (!(tileElement->properties.path.type & PATH_FLAG_QUEUE_BANNER))
             continue;
 
-        sint32 direction = ((mapElement->type >> 6) + get_current_rotation()) & 3;
+        sint32 direction = ((tileElement->type >> 6) + get_current_rotation()) & 3;
         if (direction == TILE_ELEMENT_DIRECTION_NORTH || direction == TILE_ELEMENT_DIRECTION_EAST) {
-            baseZ = mapElement->base_height * 8;
+            baseZ = tileElement->base_height * 8;
             map_invalidate_tile_zoom1(x, y, baseZ + 16, baseZ + 30);
         }
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -169,30 +169,30 @@ static bool map_animation_invalidate_queue_banner(sint32 x, sint32 y, sint32 bas
  */
 static bool map_animation_invalidate_small_scenery(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_scenery_entry *sceneryEntry;
     rct_sprite *sprite;
     rct_peep *peep;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
             continue;
-        if (mapElement->flags & (1 << 4))
+        if (tileElement->flags & (1 << 4))
             continue;
 
-        sceneryEntry = get_small_scenery_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_small_scenery_entry(tileElement->properties.scenery.type);
         if (sceneryEntry->small_scenery.flags & (SMALL_SCENERY_FLAG_FOUNTAIN_SPRAY_1 | SMALL_SCENERY_FLAG_FOUNTAIN_SPRAY_4 | SMALL_SCENERY_FLAG_SWAMP_GOO | SMALL_SCENERY_FLAG_HAS_FRAME_OFFSETS)) {
-            map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+            map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
             return false;
         }
 
         if (sceneryEntry->small_scenery.flags & SMALL_SCENERY_FLAG_IS_CLOCK) {
             // Peep, looking at scenery
             if (!(gCurrentTicks & 0x3FF) && game_is_not_paused()) {
-                sint32 direction = tile_element_get_direction(mapElement);
+                sint32 direction = tile_element_get_direction(tileElement);
                 sint32 x2 = x - TileDirectionDelta[direction].x;
                 sint32 y2 = y - TileDirectionDelta[direction].y;
 
@@ -205,7 +205,7 @@ static bool map_animation_invalidate_small_scenery(sint32 x, sint32 y, sint32 ba
                     peep = &sprite->peep;
                     if (peep->state != PEEP_STATE_WALKING)
                         continue;
-                    if (peep->z != mapElement->base_height * 8)
+                    if (peep->z != tileElement->base_height * 8)
                         continue;
                     if (peep->action < PEEP_ACTION_NONE_1)
                         continue;
@@ -218,11 +218,11 @@ static bool map_animation_invalidate_small_scenery(sint32 x, sint32 y, sint32 ba
                     break;
                 }
             }
-            map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+            map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
             return false;
         }
 
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return true;
 }
 
@@ -232,23 +232,23 @@ static bool map_animation_invalidate_small_scenery(sint32 x, sint32 y, sint32 ba
  */
 static bool map_animation_invalidate_park_entrance(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
-        if (mapElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
+        if (tileElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
             continue;
-        if (mapElement->properties.entrance.index & 0x0F)
+        if (tileElement->properties.entrance.index & 0x0F)
             continue;
 
-        baseZ = mapElement->base_height * 8;
+        baseZ = tileElement->base_height * 8;
         map_invalidate_tile_zoom1(x, y, baseZ + 32, baseZ + 64);
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -259,21 +259,21 @@ static bool map_animation_invalidate_park_entrance(sint32 x, sint32 y, sint32 ba
  */
 static bool map_animation_invalidate_track_waterfall(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if (mapElement->properties.track.type == TRACK_ELEM_WATERFALL) {
-            sint32 z = mapElement->base_height * 8;
+        if (tileElement->properties.track.type == TRACK_ELEM_WATERFALL) {
+            sint32 z = tileElement->base_height * 8;
             map_invalidate_tile_zoom1(x, y, z + 14, z + 46);
             return false;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -284,21 +284,21 @@ static bool map_animation_invalidate_track_waterfall(sint32 x, sint32 y, sint32
  */
 static bool map_animation_invalidate_track_rapids(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if (mapElement->properties.track.type == TRACK_ELEM_RAPIDS) {
-            sint32 z = mapElement->base_height * 8;
+        if (tileElement->properties.track.type == TRACK_ELEM_RAPIDS) {
+            sint32 z = tileElement->base_height * 8;
             map_invalidate_tile_zoom1(x, y, z + 14, z + 18);
             return false;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -309,30 +309,30 @@ static bool map_animation_invalidate_track_rapids(sint32 x, sint32 y, sint32 bas
  */
 static bool map_animation_invalidate_track_onridephoto(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement == NULL)
+        if (tileElement == NULL)
             break;
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if (mapElement->properties.track.type == TRACK_ELEM_ON_RIDE_PHOTO) {
-            map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+        if (tileElement->properties.track.type == TRACK_ELEM_ON_RIDE_PHOTO) {
+            map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
             if (game_is_paused()) {
                 return false;
             }
-            if (tile_element_is_taking_photo(mapElement)) {
-                tile_element_decrement_onride_photo_timout(mapElement);
+            if (tile_element_is_taking_photo(tileElement)) {
+                tile_element_decrement_onride_photo_timout(tileElement);
                 return false;
             } else {
                 return true;
             }
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -343,21 +343,21 @@ static bool map_animation_invalidate_track_onridephoto(sint32 x, sint32 y, sint3
  */
 static bool map_animation_invalidate_track_whirlpool(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if (mapElement->properties.track.type == TRACK_ELEM_WHIRLPOOL) {
-            sint32 z = mapElement->base_height * 8;
+        if (tileElement->properties.track.type == TRACK_ELEM_WHIRLPOOL) {
+            sint32 z = tileElement->base_height * 8;
             map_invalidate_tile_zoom1(x, y, z + 14, z + 18);
             return false;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -368,21 +368,21 @@ static bool map_animation_invalidate_track_whirlpool(sint32 x, sint32 y, sint32
  */
 static bool map_animation_invalidate_track_spinningtunnel(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
-        if (mapElement->properties.track.type == TRACK_ELEM_SPINNING_TUNNEL) {
-            sint32 z = mapElement->base_height * 8;
+        if (tileElement->properties.track.type == TRACK_ELEM_SPINNING_TUNNEL) {
+            sint32 z = tileElement->base_height * 8;
             map_invalidate_tile_zoom1(x, y, z + 14, z + 32);
             return false;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -402,19 +402,19 @@ static bool map_animation_invalidate_remove(sint32 x, sint32 y, sint32 baseZ)
  */
 static bool map_animation_invalidate_banner(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_BANNER)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_BANNER)
             continue;
 
-        baseZ = mapElement->base_height * 8;
+        baseZ = tileElement->base_height * 8;
         map_invalidate_tile_zoom1(x, y, baseZ, baseZ + 16);
         return false;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return true;
 }
@@ -425,24 +425,24 @@ static bool map_animation_invalidate_banner(sint32 x, sint32 y, sint32 baseZ)
  */
 static bool map_animation_invalidate_large_scenery(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_scenery_entry *sceneryEntry;
 
     bool wasInvalidated = false;
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY_MULTIPLE)
             continue;
 
-        sceneryEntry = get_large_scenery_entry(mapElement->properties.scenery.type & 0x3FF);
+        sceneryEntry = get_large_scenery_entry(tileElement->properties.scenery.type & 0x3FF);
         if (sceneryEntry->large_scenery.flags & LARGE_SCENERY_FLAG_ANIMATED) {
-            sint32 z = mapElement->base_height * 8;
+            sint32 z = tileElement->base_height * 8;
             map_invalidate_tile_zoom1(x, y, z, z + 16);
             wasInvalidated = true;
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return !wasInvalidated;
 }
@@ -453,21 +453,21 @@ static bool map_animation_invalidate_large_scenery(sint32 x, sint32 y, sint32 ba
  */
 static bool map_animation_invalidate_wall_door(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_scenery_entry *sceneryEntry;
 
     if (gCurrentTicks & 1)
         return false;
 
     bool removeAnimation = true;
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
             continue;
 
-        sceneryEntry = get_wall_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
         if (!(sceneryEntry->wall.flags & WALL_SCENERY_IS_DOOR))
             continue;
 
@@ -477,7 +477,7 @@ static bool map_animation_invalidate_wall_door(sint32 x, sint32 y, sint32 baseZ)
 
         bool invalidate = false;
 
-        uint8 currentFrame = wall_element_get_animation_frame(mapElement);
+        uint8 currentFrame = wall_element_get_animation_frame(tileElement);
         if (currentFrame != 0) {
             if (currentFrame == 15) {
                 currentFrame = 0;
@@ -492,12 +492,12 @@ static bool map_animation_invalidate_wall_door(sint32 x, sint32 y, sint32 baseZ)
                 }
             }
         }
-        wall_element_set_animation_frame(mapElement, currentFrame);
+        wall_element_set_animation_frame(tileElement, currentFrame);
         if (invalidate) {
-            sint32 z = mapElement->base_height * 8;
+            sint32 z = tileElement->base_height * 8;
             map_invalidate_tile_zoom1(x, y, z, z + 32);
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return removeAnimation;
 }
@@ -508,26 +508,26 @@ static bool map_animation_invalidate_wall_door(sint32 x, sint32 y, sint32 baseZ)
  */
 static bool map_animation_invalidate_wall(sint32 x, sint32 y, sint32 baseZ)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_scenery_entry *sceneryEntry;
 
     bool wasInvalidated = false;
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (mapElement->base_height != baseZ)
+        if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
             continue;
 
-        sceneryEntry = get_wall_entry(mapElement->properties.scenery.type);
+        sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
 
         if (!(sceneryEntry->wall.flags2 & WALL_SCENERY_2_FLAG5) && sceneryEntry->wall.scrolling_mode == 255)
             continue;
 
-        sint32 z = mapElement->base_height * 8;
+        sint32 z = tileElement->base_height * 8;
         map_invalidate_tile_zoom1(x, y, z, z + 16);
         wasInvalidated = true;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 
     return !wasInvalidated;
 }
diff --git a/src/openrct2/world/map_helpers.c b/src/openrct2/world/map_helpers.c
index 250de111d4..1cbd88e004 100644
--- a/src/openrct2/world/map_helpers.c
+++ b/src/openrct2/world/map_helpers.c
@@ -23,21 +23,21 @@
 sint32 map_smooth(sint32 l, sint32 t, sint32 r, sint32 b)
 {
     sint32 i, x, y, highest, count, cornerHeights[4], doubleCorner, raisedLand = 0;
-    rct_tile_element *mapElement, *mapElement2;
+    rct_tile_element *tileElement, *tileElement2;
     for (y = t; y < b; y++) {
         for (x = l; x < r; x++) {
-            mapElement = map_get_surface_element_at(x, y);
-            mapElement->properties.surface.slope &= ~0x1F;
+            tileElement = map_get_surface_element_at(x, y);
+            tileElement->properties.surface.slope &= ~0x1F;
 
             // Raise to edge height - 2
-            highest = mapElement->base_height;
+            highest = tileElement->base_height;
             highest = max(highest, map_get_surface_element_at(x - 1, y + 0)->base_height);
             highest = max(highest, map_get_surface_element_at(x + 1, y + 0)->base_height);
             highest = max(highest, map_get_surface_element_at(x + 0, y - 1)->base_height);
             highest = max(highest, map_get_surface_element_at(x + 0, y + 1)->base_height);
-            if (mapElement->base_height < highest - 2) {
+            if (tileElement->base_height < highest - 2) {
                 raisedLand = 1;
-                mapElement->base_height = mapElement->clearance_height = highest - 2;
+                tileElement->base_height = tileElement->clearance_height = highest - 2;
             }
 
             // Check corners
@@ -46,11 +46,11 @@ sint32 map_smooth(sint32 l, sint32 t, sint32 r, sint32 b)
             cornerHeights[1] = map_get_surface_element_at(x + 1, y - 1)->base_height;
             cornerHeights[2] = map_get_surface_element_at(x + 1, y + 1)->base_height;
             cornerHeights[3] = map_get_surface_element_at(x - 1, y + 1)->base_height;
-            highest = mapElement->base_height;
+            highest = tileElement->base_height;
             for (i = 0; i < 4; i++)
                 highest = max(highest, cornerHeights[i]);
 
-            if (highest >= mapElement->base_height + 4) {
+            if (highest >= tileElement->base_height + 4) {
                 count = 0;
                 sint32 canCompensate = 1;
                 for (i = 0; i < 4; i++)
@@ -85,16 +85,16 @@ sint32 map_smooth(sint32 l, sint32 t, sint32 r, sint32 b)
                             break;
                         }
 
-                        if (highestOnLowestSide > mapElement->base_height){
-                            mapElement->base_height = mapElement->clearance_height = highestOnLowestSide;
+                        if (highestOnLowestSide > tileElement->base_height){
+                            tileElement->base_height = tileElement->clearance_height = highestOnLowestSide;
                             raisedLand = 1;
                             canCompensate = 0;
                         }
                     }
 
                 if (count == 1 && canCompensate) {
-                    if (mapElement->base_height < highest - 4) {
-                        mapElement->base_height = mapElement->clearance_height = highest - 4;
+                    if (tileElement->base_height < highest - 4) {
+                        tileElement->base_height = tileElement->clearance_height = highest - 4;
                         raisedLand = 1;
                     }
                     if (cornerHeights[0] == highest && cornerHeights[2] <= cornerHeights[0] - 4)
@@ -106,68 +106,68 @@ sint32 map_smooth(sint32 l, sint32 t, sint32 r, sint32 b)
                     else if (cornerHeights[3] == highest && cornerHeights[1] <= cornerHeights[3] - 4)
                         doubleCorner = 3;
                 } else {
-                    if (mapElement->base_height < highest - 2) {
-                        mapElement->base_height = mapElement->clearance_height = highest - 2;
+                    if (tileElement->base_height < highest - 2) {
+                        tileElement->base_height = tileElement->clearance_height = highest - 2;
                         raisedLand = 1;
                     }
                 }
             }
 
             if (doubleCorner != -1) {
-                mapElement->properties.surface.slope |= 16;
+                tileElement->properties.surface.slope |= 16;
                 switch (doubleCorner) {
                 case 0:
-                    mapElement->properties.surface.slope |= 2 | 4 | 8;
+                    tileElement->properties.surface.slope |= 2 | 4 | 8;
                     break;
                 case 1:
-                    mapElement->properties.surface.slope |= 1 | 2 | 4;
+                    tileElement->properties.surface.slope |= 1 | 2 | 4;
                     break;
                 case 2:
-                    mapElement->properties.surface.slope |= 1 | 2 | 8;
+                    tileElement->properties.surface.slope |= 1 | 2 | 8;
                     break;
                 case 3:
-                    mapElement->properties.surface.slope |= 1 | 4 | 8;
+                    tileElement->properties.surface.slope |= 1 | 4 | 8;
                     break;
                 }
             } else {
                 // Corners
-                mapElement2 = map_get_surface_element_at(x + 1, y + 1);
-                if (mapElement2->base_height > mapElement->base_height)
-                    mapElement->properties.surface.slope |= 1;
+                tileElement2 = map_get_surface_element_at(x + 1, y + 1);
+                if (tileElement2->base_height > tileElement->base_height)
+                    tileElement->properties.surface.slope |= 1;
 
-                mapElement2 = map_get_surface_element_at(x - 1, y + 1);
-                if (mapElement2->base_height > mapElement->base_height)
-                    mapElement->properties.surface.slope |= 8;
+                tileElement2 = map_get_surface_element_at(x - 1, y + 1);
+                if (tileElement2->base_height > tileElement->base_height)
+                    tileElement->properties.surface.slope |= 8;
 
-                mapElement2 = map_get_surface_element_at(x + 1, y - 1);
-                if (mapElement2->base_height > mapElement->base_height)
-                    mapElement->properties.surface.slope |= 2;
+                tileElement2 = map_get_surface_element_at(x + 1, y - 1);
+                if (tileElement2->base_height > tileElement->base_height)
+                    tileElement->properties.surface.slope |= 2;
 
-                mapElement2 = map_get_surface_element_at(x - 1, y - 1);
-                if (mapElement2->base_height > mapElement->base_height)
-                    mapElement->properties.surface.slope |= 4;
+                tileElement2 = map_get_surface_element_at(x - 1, y - 1);
+                if (tileElement2->base_height > tileElement->base_height)
+                    tileElement->properties.surface.slope |= 4;
 
                 // Sides
-                mapElement2 = map_get_surface_element_at(x + 1, y + 0);
-                if (mapElement2->base_height > mapElement->base_height)
-                    mapElement->properties.surface.slope |= 1 | 2;
+                tileElement2 = map_get_surface_element_at(x + 1, y + 0);
+                if (tileElement2->base_height > tileElement->base_height)
+                    tileElement->properties.surface.slope |= 1 | 2;
 
-                mapElement2 = map_get_surface_element_at(x - 1, y + 0);
-                if (mapElement2->base_height > mapElement->base_height)
-                    mapElement->properties.surface.slope |= 4 | 8;
+                tileElement2 = map_get_surface_element_at(x - 1, y + 0);
+                if (tileElement2->base_height > tileElement->base_height)
+                    tileElement->properties.surface.slope |= 4 | 8;
 
-                mapElement2 = map_get_surface_element_at(x + 0, y - 1);
-                if (mapElement2->base_height > mapElement->base_height)
-                    mapElement->properties.surface.slope |= 2 | 4;
+                tileElement2 = map_get_surface_element_at(x + 0, y - 1);
+                if (tileElement2->base_height > tileElement->base_height)
+                    tileElement->properties.surface.slope |= 2 | 4;
 
-                mapElement2 = map_get_surface_element_at(x + 0, y + 1);
-                if (mapElement2->base_height > mapElement->base_height)
-                    mapElement->properties.surface.slope |= 1 | 8;
+                tileElement2 = map_get_surface_element_at(x + 0, y + 1);
+                if (tileElement2->base_height > tileElement->base_height)
+                    tileElement->properties.surface.slope |= 1 | 8;
 
                 // Raise
-                if (mapElement->properties.surface.slope == (1 | 2 | 4 | 8)) {
-                    mapElement->properties.surface.slope &= ~0x1F;
-                    mapElement->base_height = mapElement->clearance_height += 2;
+                if (tileElement->properties.surface.slope == (1 | 2 | 4 | 8)) {
+                    tileElement->properties.surface.slope &= ~0x1F;
+                    tileElement->base_height = tileElement->clearance_height += 2;
                 }
             }
         }
@@ -178,9 +178,9 @@ sint32 map_smooth(sint32 l, sint32 t, sint32 r, sint32 b)
 
 static sint32 map_get_corner_height(sint32 x, sint32 y, sint32 corner)
 {
-    rct_tile_element *mapElement = map_get_surface_element_at(x, y);
-    sint32 baseHeight = mapElement->base_height;
-    sint32 slope = mapElement->properties.surface.slope;
+    rct_tile_element *tileElement = map_get_surface_element_at(x, y);
+    sint32 baseHeight = tileElement->base_height;
+    sint32 slope = tileElement->properties.surface.slope;
     sint32 doubleCorner = slope & 16;
     if (doubleCorner) {
         if (!(slope & 1)) doubleCorner = 4;
@@ -209,21 +209,21 @@ static sint32 map_get_corner_height(sint32 x, sint32 y, sint32 corner)
 static sint32 map_smooth_wavy(sint32 l, sint32 t, sint32 r, sint32 b)
 {
     sint32 i, x, y, highest, count, cornerHeights[4], doubleCorner, raisedLand = 0;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     for (y = t; y < b; y++) {
         for (x = l; x < r; x++) {
-            mapElement = map_get_surface_element_at(x, y);
-            mapElement->properties.surface.slope &= ~0x1F;
+            tileElement = map_get_surface_element_at(x, y);
+            tileElement->properties.surface.slope &= ~0x1F;
 
             // Raise to edge height - 2
-            highest = mapElement->base_height;
+            highest = tileElement->base_height;
             highest = max(highest, map_get_surface_element_at(x - 1, y + 0)->base_height);
             highest = max(highest, map_get_surface_element_at(x + 1, y + 0)->base_height);
             highest = max(highest, map_get_surface_element_at(x + 0, y - 1)->base_height);
             highest = max(highest, map_get_surface_element_at(x + 0, y + 1)->base_height);
-            if (mapElement->base_height < highest - 2) {
+            if (tileElement->base_height < highest - 2) {
                 raisedLand = 1;
-                mapElement->base_height = mapElement->clearance_height = highest - 2;
+                tileElement->base_height = tileElement->clearance_height = highest - 2;
             }
 
             // Check corners
@@ -232,19 +232,19 @@ static sint32 map_smooth_wavy(sint32 l, sint32 t, sint32 r, sint32 b)
             cornerHeights[1] = max(map_get_corner_height(x + 1, y - 1, 1), max(map_get_corner_height(x - 1, y + 0, 0), map_get_corner_height(x + 0, y + 1, 3)));
             cornerHeights[2] = max(map_get_corner_height(x + 1, y + 1, 3), max(map_get_corner_height(x + 1, y + 0, 3), map_get_corner_height(x + 0, y - 1, 0)));
             cornerHeights[3] = max(map_get_corner_height(x - 1, y + 1, 2), max(map_get_corner_height(x - 1, y + 0, 2), map_get_corner_height(x + 0, y - 1, 1)));
-            highest = mapElement->base_height;
+            highest = tileElement->base_height;
             for (i = 0; i < 4; i++)
                 highest = max(highest, cornerHeights[i]);
 
-            if (highest >= mapElement->base_height + 4) {
+            if (highest >= tileElement->base_height + 4) {
                 count = 0;
                 for (i = 0; i < 4; i++)
                     if (cornerHeights[i] == highest)
                         count++;
 
                 if (count == 1) {
-                    if (mapElement->base_height < highest - 4) {
-                        mapElement->base_height = mapElement->clearance_height = highest - 4;
+                    if (tileElement->base_height < highest - 4) {
+                        tileElement->base_height = tileElement->clearance_height = highest - 4;
                         raisedLand = 1;
                     }
                     if (cornerHeights[0] == highest && cornerHeights[2] <= cornerHeights[0] - 4)
@@ -256,63 +256,63 @@ static sint32 map_smooth_wavy(sint32 l, sint32 t, sint32 r, sint32 b)
                     else if (cornerHeights[3] == highest && cornerHeights[1] <= cornerHeights[3] - 4)
                         doubleCorner = 3;
                 } else {
-                    if (mapElement->base_height < highest - 2) {
-                        mapElement->base_height = mapElement->clearance_height = highest - 2;
+                    if (tileElement->base_height < highest - 2) {
+                        tileElement->base_height = tileElement->clearance_height = highest - 2;
                         raisedLand = 1;
                     }
                 }
             }
 
             if (doubleCorner != -1) {
-                mapElement->properties.surface.slope |= 16;
+                tileElement->properties.surface.slope |= 16;
                 switch (doubleCorner) {
                 case 0:
-                    mapElement->properties.surface.slope |= 2 | 4 | 8;
+                    tileElement->properties.surface.slope |= 2 | 4 | 8;
                     break;
                 case 1:
-                    mapElement->properties.surface.slope |= 1 | 2 | 4;
+                    tileElement->properties.surface.slope |= 1 | 2 | 4;
                     break;
                 case 2:
-                    mapElement->properties.surface.slope |= 1 | 2 | 8;
+                    tileElement->properties.surface.slope |= 1 | 2 | 8;
                     break;
                 case 3:
-                    mapElement->properties.surface.slope |= 1 | 4 | 8;
+                    tileElement->properties.surface.slope |= 1 | 4 | 8;
                     break;
                 }
             } else {
                 // Corners
                 if (
-                    map_get_corner_height(x + 1, y + 1, 3) > mapElement->base_height ||
-                    map_get_corner_height(x + 1, y + 0, 1) > mapElement->base_height ||
-                    map_get_corner_height(x + 0, y + 1, 2) > mapElement->base_height
+                    map_get_corner_height(x + 1, y + 1, 3) > tileElement->base_height ||
+                    map_get_corner_height(x + 1, y + 0, 1) > tileElement->base_height ||
+                    map_get_corner_height(x + 0, y + 1, 2) > tileElement->base_height
                 )
-                    mapElement->properties.surface.slope |= 1;
+                    tileElement->properties.surface.slope |= 1;
 
                 if (
-                    map_get_corner_height(x - 1, y + 1, 2) > mapElement->base_height ||
-                    map_get_corner_height(x - 1, y + 0, 0) > mapElement->base_height ||
-                    map_get_corner_height(x + 0, y + 1, 3) > mapElement->base_height
+                    map_get_corner_height(x - 1, y + 1, 2) > tileElement->base_height ||
+                    map_get_corner_height(x - 1, y + 0, 0) > tileElement->base_height ||
+                    map_get_corner_height(x + 0, y + 1, 3) > tileElement->base_height
                 )
-                    mapElement->properties.surface.slope |= 8;
+                    tileElement->properties.surface.slope |= 8;
 
                 if (
-                    map_get_corner_height(x + 1, y - 1, 1) > mapElement->base_height ||
-                    map_get_corner_height(x + 1, y + 0, 3) > mapElement->base_height ||
-                    map_get_corner_height(x + 0, y - 1, 0) > mapElement->base_height
+                    map_get_corner_height(x + 1, y - 1, 1) > tileElement->base_height ||
+                    map_get_corner_height(x + 1, y + 0, 3) > tileElement->base_height ||
+                    map_get_corner_height(x + 0, y - 1, 0) > tileElement->base_height
                 )
-                    mapElement->properties.surface.slope |= 2;
+                    tileElement->properties.surface.slope |= 2;
 
                 if (
-                    map_get_corner_height(x - 1, y - 1, 0) > mapElement->base_height ||
-                    map_get_corner_height(x - 1, y + 0, 2) > mapElement->base_height ||
-                    map_get_corner_height(x + 0, y - 1, 1) > mapElement->base_height
+                    map_get_corner_height(x - 1, y - 1, 0) > tileElement->base_height ||
+                    map_get_corner_height(x - 1, y + 0, 2) > tileElement->base_height ||
+                    map_get_corner_height(x + 0, y - 1, 1) > tileElement->base_height
                 )
-                    mapElement->properties.surface.slope |= 4;
+                    tileElement->properties.surface.slope |= 4;
 
                 // Raise
-                if (mapElement->properties.surface.slope == (1 | 2 | 4 | 8)) {
-                    mapElement->properties.surface.slope &= ~0x1F;
-                    mapElement->base_height = mapElement->clearance_height += 2;
+                if (tileElement->properties.surface.slope == (1 | 2 | 4 | 8)) {
+                    tileElement->properties.surface.slope &= ~0x1F;
+                    tileElement->base_height = tileElement->clearance_height += 2;
                 }
             }
         }
diff --git a/src/openrct2/world/mapgen.c b/src/openrct2/world/mapgen.c
index 7502174ea5..0d6504d4e8 100644
--- a/src/openrct2/world/mapgen.c
+++ b/src/openrct2/world/mapgen.c
@@ -115,18 +115,18 @@ static void set_height(sint32 x, sint32 y, sint32 height)
 void mapgen_generate_blank(mapgen_settings *settings)
 {
     sint32 x, y;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     map_clear_all_elements();
 
     map_init(settings->mapSize);
     for (y = 1; y < settings->mapSize - 1; y++) {
         for (x = 1; x < settings->mapSize - 1; x++) {
-            mapElement = map_get_surface_element_at(x, y);
-            tile_element_set_terrain(mapElement, settings->floor);
-            tile_element_set_terrain_edge(mapElement, settings->wall);
-            mapElement->base_height = settings->height;
-            mapElement->clearance_height = settings->height;
+            tileElement = map_get_surface_element_at(x, y);
+            tile_element_set_terrain(tileElement, settings->floor);
+            tile_element_set_terrain_edge(tileElement, settings->wall);
+            tileElement->base_height = settings->height;
+            tileElement->clearance_height = settings->height;
         }
     }
 
@@ -136,7 +136,7 @@ void mapgen_generate_blank(mapgen_settings *settings)
 void mapgen_generate(mapgen_settings *settings)
 {
     sint32 x, y, mapSize, floorTexture, wallTexture, waterLevel;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     util_srand((sint32)platform_get_ticks());
 
@@ -169,11 +169,11 @@ void mapgen_generate(mapgen_settings *settings)
     map_init(mapSize);
     for (y = 1; y < mapSize - 1; y++) {
         for (x = 1; x < mapSize - 1; x++) {
-            mapElement = map_get_surface_element_at(x, y);
-            tile_element_set_terrain(mapElement, floorTexture);
-            tile_element_set_terrain_edge(mapElement, wallTexture);
-            mapElement->base_height = settings->height;
-            mapElement->clearance_height = settings->height;
+            tileElement = map_get_surface_element_at(x, y);
+            tile_element_set_terrain(tileElement, floorTexture);
+            tile_element_set_terrain_edge(tileElement, wallTexture);
+            tileElement->base_height = settings->height;
+            tileElement->clearance_height = settings->height;
         }
     }
 
@@ -223,10 +223,10 @@ void mapgen_generate(mapgen_settings *settings)
     }
     for (y = 1; y < mapSize - 1; y++) {
         for (x = 1; x < mapSize - 1; x++) {
-            mapElement = map_get_surface_element_at(x, y);
+            tileElement = map_get_surface_element_at(x, y);
 
-            if (mapElement->base_height < waterLevel + 6)
-                tile_element_set_terrain(mapElement, beachTexture);
+            if (tileElement->base_height < waterLevel + 6)
+                tile_element_set_terrain(tileElement, beachTexture);
         }
     }
 
@@ -240,18 +240,18 @@ void mapgen_generate(mapgen_settings *settings)
 static void mapgen_place_tree(sint32 type, sint32 x, sint32 y)
 {
     sint32 surfaceZ;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
     rct_scenery_entry *sceneryEntry = get_small_scenery_entry(type);
 
     surfaceZ = tile_element_height(x * 32 + 16, y * 32 + 16) / 8;
-    mapElement = tile_element_insert(x, y, surfaceZ, (1 | 2 | 4 | 8));
-    assert(mapElement != NULL);
-    mapElement->clearance_height = surfaceZ + (sceneryEntry->small_scenery.height >> 3);
+    tileElement = tile_element_insert(x, y, surfaceZ, (1 | 2 | 4 | 8));
+    assert(tileElement != NULL);
+    tileElement->clearance_height = surfaceZ + (sceneryEntry->small_scenery.height >> 3);
 
-    mapElement->type = TILE_ELEMENT_TYPE_SCENERY | (util_rand() & 3);
-    mapElement->properties.scenery.type = type;
-    mapElement->properties.scenery.age = 0;
-    scenery_small_set_primary_colour(mapElement, COLOUR_YELLOW);
+    tileElement->type = TILE_ELEMENT_TYPE_SCENERY | (util_rand() & 3);
+    tileElement->properties.scenery.type = type;
+    tileElement->properties.scenery.age = 0;
+    scenery_small_set_primary_colour(tileElement, COLOUR_YELLOW);
 }
 
 /**
@@ -304,10 +304,10 @@ static void mapgen_place_trees()
     // Create list of available tiles
     for (sint32 y = 1; y < gMapSize - 1; y++) {
         for (sint32 x = 1; x < gMapSize - 1; x++) {
-            rct_tile_element *mapElement = map_get_surface_element_at(x, y);
+            rct_tile_element *tileElement = map_get_surface_element_at(x, y);
 
             // Exclude water tiles
-            if (map_get_water_height(mapElement) > 0)
+            if (map_get_water_height(tileElement) > 0)
                 continue;
 
             pos = &availablePositions[availablePositionsCount++];
@@ -335,8 +335,8 @@ static void mapgen_place_trees()
         pos = &availablePositions[i];
 
         sint32 type = -1;
-        rct_tile_element *mapElement = map_get_surface_element_at(pos->x, pos->y);
-        switch (tile_element_get_terrain(mapElement)) {
+        rct_tile_element *tileElement = map_get_surface_element_at(pos->x, pos->y);
+        switch (tile_element_get_terrain(tileElement)) {
         case TERRAIN_GRASS:
         case TERRAIN_DIRT:
         case TERRAIN_GRASS_CLUMPS:
@@ -380,15 +380,15 @@ static void mapgen_place_trees()
 static void mapgen_set_water_level(sint32 waterLevel)
 {
     sint32 x, y, mapSize;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     mapSize = gMapSize;
 
     for (y = 1; y < mapSize - 1; y++) {
         for (x = 1; x < mapSize - 1; x++) {
-            mapElement = map_get_surface_element_at(x, y);
-            if (mapElement->base_height < waterLevel)
-                mapElement->properties.surface.terrain |= (waterLevel  / 2);
+            tileElement = map_get_surface_element_at(x, y);
+            if (tileElement->base_height < waterLevel)
+                tileElement->properties.surface.terrain |= (waterLevel  / 2);
         }
     }
 }
@@ -613,7 +613,7 @@ static void mapgen_smooth_height(sint32 iterations)
 static void mapgen_set_height()
 {
     sint32 x, y, heightX, heightY, mapSize;
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     mapSize = _heightSize / 2;
     for (y = 1; y < mapSize - 1; y++) {
@@ -628,18 +628,18 @@ static void mapgen_set_height()
 
             uint8 baseHeight = (q00 + q01 + q10 + q11) / 4;
 
-            mapElement = map_get_surface_element_at(x, y);
-            mapElement->base_height = max(2, baseHeight * 2);
-            mapElement->clearance_height = mapElement->base_height;
+            tileElement = map_get_surface_element_at(x, y);
+            tileElement->base_height = max(2, baseHeight * 2);
+            tileElement->clearance_height = tileElement->base_height;
 
             if (q00 > baseHeight)
-                mapElement->properties.surface.slope |= 4;
+                tileElement->properties.surface.slope |= 4;
             if (q01 > baseHeight)
-                mapElement->properties.surface.slope |= 8;
+                tileElement->properties.surface.slope |= 8;
             if (q10 > baseHeight)
-                mapElement->properties.surface.slope |= 2;
+                tileElement->properties.surface.slope |= 2;
             if (q11 > baseHeight)
-                mapElement->properties.surface.slope |= 1;
+                tileElement->properties.surface.slope |= 1;
         }
     }
 }
diff --git a/src/openrct2/world/park.c b/src/openrct2/world/park.c
index 5d83f5eccf..98707498c9 100644
--- a/src/openrct2/world/park.c
+++ b/src/openrct2/world/park.c
@@ -709,20 +709,20 @@ void update_park_fences(sint32 x, sint32 y)
     if ((sufaceElement->properties.surface.ownership & OWNERSHIP_OWNED) == 0) {
         uint8 fence_required = 1;
 
-        rct_tile_element* mapElement = map_get_first_element_at(x / 32, y / 32);
+        rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
         // If an entrance element do not place flags around surface
         do {
-            if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
 
-            if (mapElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
+            if (tileElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
                 continue;
 
-            if (!(mapElement->flags & TILE_ELEMENT_FLAG_GHOST)) {
+            if (!(tileElement->flags & TILE_ELEMENT_FLAG_GHOST)) {
                 fence_required = 0;
                 break;
             }
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
 
         if (fence_required) {
             // As map_is_location_in_park sets the error text
@@ -933,9 +933,9 @@ static money32 map_buy_land_rights_for_tile(sint32 x, sint32 y, sint32 setting,
             return 0;
         }
 
-        rct_tile_element* mapElement = map_get_first_element_at(x / 32, y / 32);
+        rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
         do {
-            if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+            if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
                 // Do not allow ownership of park entrance.
                 if (newOwnership == OWNERSHIP_OWNED || newOwnership == OWNERSHIP_AVAILABLE)
                     return 0;
@@ -943,11 +943,11 @@ static money32 map_buy_land_rights_for_tile(sint32 x, sint32 y, sint32 setting,
                 // There is no need to check the height if newOwnership is 0 (unowned and no rights available).
                 if ((newOwnership == OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED ||
                      newOwnership == OWNERSHIP_CONSTRUCTION_RIGHTS_AVAILABLE) &&
-                    (mapElement->base_height - 3 > surfaceElement->base_height ||
-                     mapElement->base_height < surfaceElement->base_height))
+                    (tileElement->base_height - 3 > surfaceElement->base_height ||
+                     tileElement->base_height < surfaceElement->base_height))
                     return 0;
             }
-        } while (!tile_element_is_last_for_tile(mapElement++));
+        } while (!tile_element_is_last_for_tile(tileElement++));
 
         if (!(flags & GAME_COMMAND_FLAG_APPLY)) {
             return gLandPrice;
diff --git a/src/openrct2/world/scenery.c b/src/openrct2/world/scenery.c
index e1235b1147..cf25961c62 100644
--- a/src/openrct2/world/scenery.c
+++ b/src/openrct2/world/scenery.c
@@ -38,8 +38,8 @@ colour_t gWindowScenerySecondaryColour;
 colour_t gWindowSceneryTertiaryColour;
 bool gWindowSceneryEyedropperEnabled;
 
-rct_tile_element *gSceneryMapElement;
-uint8 gSceneryMapElementType;
+rct_tile_element *gSceneryTileElement;
+uint8 gSceneryTileElementType;
 
 money32 gSceneryPlaceCost;
 sint16 gSceneryPlaceObject;
@@ -73,50 +73,50 @@ const LocationXY8 ScenerySubTileOffsets[] = {
     { 23,  7 }
 };
 
-void scenery_increase_age(sint32 x, sint32 y, rct_tile_element *mapElement);
+void scenery_increase_age(sint32 x, sint32 y, rct_tile_element *tileElement);
 
 void scenery_update_tile(sint32 x, sint32 y)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
         if (network_get_mode() != NETWORK_MODE_NONE)
         {
-            if (tile_element_is_ghost(mapElement))
+            if (tile_element_is_ghost(tileElement))
                 continue;
         }
 
-        if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_SCENERY) {
-            scenery_update_age(x, y, mapElement);
-        } else if (tile_element_get_type(mapElement) == TILE_ELEMENT_TYPE_PATH) {
-            if (footpath_element_has_path_scenery(mapElement) && !footpath_element_path_scenery_is_ghost(mapElement)) {
-                rct_scenery_entry *sceneryEntry = get_footpath_item_entry(footpath_element_get_path_scenery_index(mapElement));
+        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SCENERY) {
+            scenery_update_age(x, y, tileElement);
+        } else if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+            if (footpath_element_has_path_scenery(tileElement) && !footpath_element_path_scenery_is_ghost(tileElement)) {
+                rct_scenery_entry *sceneryEntry = get_footpath_item_entry(footpath_element_get_path_scenery_index(tileElement));
                 if (sceneryEntry != NULL) {
                     if (sceneryEntry->path_bit.flags & PATH_BIT_FLAG_JUMPING_FOUNTAIN_WATER) {
-                        jumping_fountain_begin(JUMPING_FOUNTAIN_TYPE_WATER, x, y, mapElement);
+                        jumping_fountain_begin(JUMPING_FOUNTAIN_TYPE_WATER, x, y, tileElement);
                     }
                     else if (sceneryEntry->path_bit.flags & PATH_BIT_FLAG_JUMPING_FOUNTAIN_SNOW) {
-                        jumping_fountain_begin(JUMPING_FOUNTAIN_TYPE_SNOW, x, y, mapElement);
+                        jumping_fountain_begin(JUMPING_FOUNTAIN_TYPE_SNOW, x, y, tileElement);
                     }
                 }
             }
         }
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
 }
 
 /**
  *
  *  rct2: 0x006E33D9
  */
-void scenery_update_age(sint32 x, sint32 y, rct_tile_element *mapElement)
+void scenery_update_age(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    rct_tile_element *mapElementAbove;
+    rct_tile_element *tileElementAbove;
     rct_scenery_entry *sceneryEntry;
 
-    sceneryEntry = get_small_scenery_entry(mapElement->properties.scenery.type);
+    sceneryEntry = get_small_scenery_entry(tileElement->properties.scenery.type);
     if (sceneryEntry == NULL)
     {
         return;
@@ -130,34 +130,34 @@ void scenery_update_age(sint32 x, sint32 y, rct_tile_element *mapElement)
     if (
         !(sceneryEntry->small_scenery.flags & SMALL_SCENERY_FLAG_CAN_BE_WATERED) ||
         (gClimateCurrentWeather < WEATHER_RAIN) ||
-        (mapElement->properties.scenery.age < 5)
+        (tileElement->properties.scenery.age < 5)
     ) {
-        scenery_increase_age(x, y, mapElement);
+        scenery_increase_age(x, y, tileElement);
         return;
     }
 
     // Check map elements above, presumably to see if map element is blocked from rain
-    mapElementAbove = mapElement;
-    while (!(mapElementAbove->flags & 7)) {
+    tileElementAbove = tileElement;
+    while (!(tileElementAbove->flags & 7)) {
 
-        mapElementAbove++;
+        tileElementAbove++;
 
         // Ghosts are purely this-client-side and should not cause any interaction,
         // as that may lead to a desync.
-        if (tile_element_is_ghost(mapElementAbove))
+        if (tile_element_is_ghost(tileElementAbove))
             continue;
 
-        switch (tile_element_get_type(mapElementAbove)) {
+        switch (tile_element_get_type(tileElementAbove)) {
         case TILE_ELEMENT_TYPE_SCENERY_MULTIPLE:
         case TILE_ELEMENT_TYPE_ENTRANCE:
         case TILE_ELEMENT_TYPE_PATH:
-            map_invalidate_tile_zoom1(x, y, mapElementAbove->base_height * 8, mapElementAbove->clearance_height * 8);
-            scenery_increase_age(x, y, mapElement);
+            map_invalidate_tile_zoom1(x, y, tileElementAbove->base_height * 8, tileElementAbove->clearance_height * 8);
+            scenery_increase_age(x, y, tileElement);
             return;
         case TILE_ELEMENT_TYPE_SCENERY:
-            sceneryEntry = get_small_scenery_entry(mapElementAbove->properties.scenery.type);
+            sceneryEntry = get_small_scenery_entry(tileElementAbove->properties.scenery.type);
             if (sceneryEntry->small_scenery.flags & SMALL_SCENERY_FLAG_VOFFSET_CENTRE) {
-                scenery_increase_age(x, y, mapElement);
+                scenery_increase_age(x, y, tileElement);
                 return;
             }
             break;
@@ -165,18 +165,18 @@ void scenery_update_age(sint32 x, sint32 y, rct_tile_element *mapElement)
     }
 
     // Reset age / water plant
-    mapElement->properties.scenery.age = 0;
-    map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+    tileElement->properties.scenery.age = 0;
+    map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
 }
 
-void scenery_increase_age(sint32 x, sint32 y, rct_tile_element *mapElement)
+void scenery_increase_age(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    if (mapElement->flags & SMALL_SCENERY_FLAG_ANIMATED)
+    if (tileElement->flags & SMALL_SCENERY_FLAG_ANIMATED)
         return;
 
-    if (mapElement->properties.scenery.age < 255) {
-        mapElement->properties.scenery.age++;
-        map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
+    if (tileElement->properties.scenery.age < 255) {
+        tileElement->properties.scenery.age++;
+        map_invalidate_tile_zoom1(x, y, tileElement->base_height * 8, tileElement->clearance_height * 8);
     }
 }
 
@@ -195,7 +195,7 @@ void scenery_remove_ghost_tool_placement(){
         gSceneryGhostType &= ~(1 << 0);
         game_do_command(
             x,
-            105 | (gSceneryMapElementType << 8),
+            105 | (gSceneryTileElementType << 8),
             y,
             z | (gSceneryPlaceObject << 8),
             GAME_COMMAND_REMOVE_SCENERY,
@@ -230,7 +230,7 @@ void scenery_remove_ghost_tool_placement(){
         gSceneryGhostType &= ~(1 << 2);
         game_do_command(
             x,
-            105 | (gSceneryMapElementType << 8),
+            105 | (gSceneryTileElementType << 8),
             y,
             gSceneryGhostWallRotation |(z << 8),
             GAME_COMMAND_REMOVE_WALL,
@@ -323,37 +323,37 @@ sint32 get_scenery_id_from_entry_index(uint8 objectType, sint32 entryIndex)
     }
 }
 
-sint32 scenery_small_get_primary_colour(const rct_tile_element *mapElement)
+sint32 scenery_small_get_primary_colour(const rct_tile_element *tileElement)
 {
-    return (mapElement->properties.scenery.colour_1 & 0x1F);
+    return (tileElement->properties.scenery.colour_1 & 0x1F);
 }
 
-sint32 scenery_small_get_secondary_colour(const rct_tile_element *mapElement)
+sint32 scenery_small_get_secondary_colour(const rct_tile_element *tileElement)
 {
-    return (mapElement->properties.scenery.colour_2 & 0x1F);
+    return (tileElement->properties.scenery.colour_2 & 0x1F);
 }
 
-void scenery_small_set_primary_colour(rct_tile_element *mapElement, uint32 colour)
+void scenery_small_set_primary_colour(rct_tile_element *tileElement, uint32 colour)
 {
     assert(colour <= 31);
-    mapElement->properties.scenery.colour_1 &= ~0x1F;
-    mapElement->properties.scenery.colour_1 |= colour;
+    tileElement->properties.scenery.colour_1 &= ~0x1F;
+    tileElement->properties.scenery.colour_1 |= colour;
 
 }
 
-void scenery_small_set_secondary_colour(rct_tile_element *mapElement, uint32 colour)
+void scenery_small_set_secondary_colour(rct_tile_element *tileElement, uint32 colour)
 {
     assert(colour <= 31);
-    mapElement->properties.scenery.colour_2 &= ~0x1F;
-    mapElement->properties.scenery.colour_2 |= colour;
+    tileElement->properties.scenery.colour_2 &= ~0x1F;
+    tileElement->properties.scenery.colour_2 |= colour;
 }
 
-bool scenery_small_get_supports_needed(const rct_tile_element *mapElement)
+bool scenery_small_get_supports_needed(const rct_tile_element *tileElement)
 {
-    return (bool)(mapElement->properties.scenery.colour_1 & MAP_ELEM_SMALL_SCENERY_COLOUR_FLAG_NEEDS_SUPPORTS);
+    return (bool)(tileElement->properties.scenery.colour_1 & MAP_ELEM_SMALL_SCENERY_COLOUR_FLAG_NEEDS_SUPPORTS);
 }
 
-void scenery_small_set_supports_needed(rct_tile_element *mapElement)
+void scenery_small_set_supports_needed(rct_tile_element *tileElement)
 {
-    mapElement->properties.scenery.colour_1 |= MAP_ELEM_SMALL_SCENERY_COLOUR_FLAG_NEEDS_SUPPORTS;
+    tileElement->properties.scenery.colour_1 |= MAP_ELEM_SMALL_SCENERY_COLOUR_FLAG_NEEDS_SUPPORTS;
 }
diff --git a/src/openrct2/world/scenery.h b/src/openrct2/world/scenery.h
index ad787de6fe..84913cd1fc 100644
--- a/src/openrct2/world/scenery.h
+++ b/src/openrct2/world/scenery.h
@@ -252,8 +252,8 @@ extern colour_t gWindowScenerySecondaryColour;
 extern colour_t gWindowSceneryTertiaryColour;
 extern bool gWindowSceneryEyedropperEnabled;
 
-extern rct_tile_element *gSceneryMapElement;
-extern uint8 gSceneryMapElementType;
+extern rct_tile_element *gSceneryTileElement;
+extern uint8 gSceneryTileElementType;
 
 extern money32 gSceneryPlaceCost;
 extern sint16 gSceneryPlaceObject;
@@ -285,7 +285,7 @@ extern money32 gClearSceneryCost;
 
 void init_scenery();
 void scenery_update_tile(sint32 x, sint32 y);
-void scenery_update_age(sint32 x, sint32 y, rct_tile_element *mapElement);
+void scenery_update_age(sint32 x, sint32 y, rct_tile_element *tileElement);
 void scenery_set_default_placement_configuration();
 void scenery_remove_ghost_tool_placement();
 bool window_scenery_set_selected_item(sint32 sceneryId);
@@ -299,12 +299,12 @@ rct_scenery_set_entry *get_scenery_group_entry(sint32 entryIndex);
 
 sint32 get_scenery_id_from_entry_index(uint8 objectType, sint32 entryIndex);
 
-sint32 scenery_small_get_primary_colour(const rct_tile_element *mapElement);
-sint32 scenery_small_get_secondary_colour(const rct_tile_element *mapElement);
-void scenery_small_set_primary_colour(rct_tile_element *mapElement, uint32 colour);
-void scenery_small_set_secondary_colour(rct_tile_element *mapElement, uint32 colour);
-bool scenery_small_get_supports_needed(const rct_tile_element *mapElement);
-void scenery_small_set_supports_needed(rct_tile_element *mapElement);
+sint32 scenery_small_get_primary_colour(const rct_tile_element *tileElement);
+sint32 scenery_small_get_secondary_colour(const rct_tile_element *tileElement);
+void scenery_small_set_primary_colour(rct_tile_element *tileElement, uint32 colour);
+void scenery_small_set_secondary_colour(rct_tile_element *tileElement, uint32 colour);
+bool scenery_small_get_supports_needed(const rct_tile_element *tileElement);
+void scenery_small_set_supports_needed(rct_tile_element *tileElement);
 
 #ifdef __cplusplus
 }
diff --git a/src/openrct2/world/sprite.c b/src/openrct2/world/sprite.c
index 47bafc842a..93cce6fc3f 100644
--- a/src/openrct2/world/sprite.c
+++ b/src/openrct2/world/sprite.c
@@ -627,25 +627,25 @@ void sprite_remove(rct_sprite *sprite)
 
 static bool litter_can_be_at(sint32 x, sint32 y, sint32 z)
 {
-    rct_tile_element *mapElement;
+    rct_tile_element *tileElement;
 
     if (!map_is_location_owned(x & 0xFFE0, y & 0xFFE0, z))
         return false;
 
-    mapElement = map_get_first_element_at(x >> 5, y >> 5);
+    tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        sint32 pathZ = mapElement->base_height * 8;
+        sint32 pathZ = tileElement->base_height * 8;
         if (pathZ < z || pathZ >= z + 32)
             continue;
 
-        if (tile_element_is_underground(mapElement))
+        if (tile_element_is_underground(tileElement))
             return false;
 
         return true;
-    } while (!tile_element_is_last_for_tile(mapElement++));
+    } while (!tile_element_is_last_for_tile(tileElement++));
     return false;
 }
 
diff --git a/src/openrct2/world/tile_inspector.c b/src/openrct2/world/tile_inspector.c
index 68512ed795..c59855ba62 100644
--- a/src/openrct2/world/tile_inspector.c
+++ b/src/openrct2/world/tile_inspector.c
@@ -139,11 +139,11 @@ sint32 tile_inspector_remove_element_at(sint32 x, sint32 y, sint16 elementIndex,
     if (flags & GAME_COMMAND_FLAG_APPLY)
     {
         // Forcefully remove the element
-        rct_tile_element *const mapElement = map_get_nth_element_at(x, y, elementIndex);
-        if (!mapElement) {
+        rct_tile_element *const tileElement = map_get_nth_element_at(x, y, elementIndex);
+        if (!tileElement) {
             return MONEY32_UNDEFINED;
         }
-        tile_element_remove(mapElement);
+        tile_element_remove(tileElement);
         map_invalidate_tile_full(x << 5, y << 5);
 
         // Update the window
@@ -203,38 +203,38 @@ sint32 tile_inspector_rotate_element_at(sint32 x, sint32 y, sint32 elementIndex,
     {
         uint8 newRotation, pathEdges, pathCorners;
 
-        rct_tile_element *const mapElement = map_get_nth_element_at(x, y, elementIndex);
-        if (!mapElement) {
+        rct_tile_element *const tileElement = map_get_nth_element_at(x, y, elementIndex);
+        if (!tileElement) {
             return MONEY32_UNDEFINED;
         }
-        switch (tile_element_get_type(mapElement))
+        switch (tile_element_get_type(tileElement))
         {
         case TILE_ELEMENT_TYPE_PATH:
-            if (footpath_element_is_sloped(mapElement))
+            if (footpath_element_is_sloped(tileElement))
             {
-                newRotation = (footpath_element_get_slope_direction(mapElement) + 1) & TILE_ELEMENT_DIRECTION_MASK;
-                mapElement->properties.path.type &= ~TILE_ELEMENT_DIRECTION_MASK;
-                mapElement->properties.path.type |= newRotation;
+                newRotation = (footpath_element_get_slope_direction(tileElement) + 1) & TILE_ELEMENT_DIRECTION_MASK;
+                tileElement->properties.path.type &= ~TILE_ELEMENT_DIRECTION_MASK;
+                tileElement->properties.path.type |= newRotation;
             }
-            pathEdges = mapElement->properties.path.edges & 0x0F;
-            pathCorners = mapElement->properties.path.edges & 0xF0;
-            mapElement->properties.path.edges = 0;
-            mapElement->properties.path.edges |= ((pathEdges << 1) | (pathEdges >> 3)) & 0x0F;
-            mapElement->properties.path.edges |= ((pathCorners << 1) | (pathCorners >> 3)) & 0xF0;
+            pathEdges = tileElement->properties.path.edges & 0x0F;
+            pathCorners = tileElement->properties.path.edges & 0xF0;
+            tileElement->properties.path.edges = 0;
+            tileElement->properties.path.edges |= ((pathEdges << 1) | (pathEdges >> 3)) & 0x0F;
+            tileElement->properties.path.edges |= ((pathCorners << 1) | (pathCorners >> 3)) & 0xF0;
             break;
         case TILE_ELEMENT_TYPE_TRACK:
         case TILE_ELEMENT_TYPE_SCENERY:
         case TILE_ELEMENT_TYPE_ENTRANCE:
         case TILE_ELEMENT_TYPE_WALL:
-            newRotation = tile_element_get_direction_with_offset(mapElement, 1);
-            mapElement->type &= ~TILE_ELEMENT_DIRECTION_MASK;
-            mapElement->type |= newRotation;
+            newRotation = tile_element_get_direction_with_offset(tileElement, 1);
+            tileElement->type &= ~TILE_ELEMENT_DIRECTION_MASK;
+            tileElement->type |= newRotation;
             break;
         case TILE_ELEMENT_TYPE_BANNER:
-            mapElement->properties.banner.flags ^= 1 << mapElement->properties.banner.position;
-            mapElement->properties.banner.position++;
-            mapElement->properties.banner.position &= 3;
-            mapElement->properties.banner.flags ^= 1 << mapElement->properties.banner.position;
+            tileElement->properties.banner.flags ^= 1 << tileElement->properties.banner.position;
+            tileElement->properties.banner.position++;
+            tileElement->properties.banner.position &= 3;
+            tileElement->properties.banner.flags ^= 1 << tileElement->properties.banner.position;
             break;
         }
 
@@ -348,12 +348,12 @@ sint32 tile_inspector_sort_elements_at(sint32 x, sint32 y, sint32 flags)
 
 sint32 tile_inspector_any_base_height_offset(sint32 x, sint32 y, sint16 elementIndex, sint8 heightOffset, sint32 flags)
 {
-    rct_tile_element *const mapElement = map_get_nth_element_at(x, y, elementIndex);
-    if (!mapElement) {
+    rct_tile_element *const tileElement = map_get_nth_element_at(x, y, elementIndex);
+    if (!tileElement) {
         return MONEY32_UNDEFINED;
     }
-    sint16 newBaseHeight = (sint16)mapElement->base_height + heightOffset;
-    sint16 newClearanceHeight = (sint16)mapElement->clearance_height + heightOffset;
+    sint16 newBaseHeight = (sint16)tileElement->base_height + heightOffset;
+    sint16 newClearanceHeight = (sint16)tileElement->clearance_height + heightOffset;
     if (newBaseHeight < 0 || newBaseHeight > 0xff || newClearanceHeight < 0 || newClearanceHeight > 0xff)
     {
         return MONEY32_UNDEFINED;
@@ -361,8 +361,8 @@ sint32 tile_inspector_any_base_height_offset(sint32 x, sint32 y, sint16 elementI
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
     {
-        mapElement->base_height += heightOffset;
-        mapElement->clearance_height += heightOffset;
+        tileElement->base_height += heightOffset;
+        tileElement->clearance_height += heightOffset;
 
         map_invalidate_tile_full(x << 5, y << 5);
 
@@ -657,27 +657,27 @@ sint32 tile_inspector_track_base_height_offset(sint32 x, sint32 y, sint32 elemen
             map_invalidate_tile_full(elemX, elemY);
 
             bool found = false;
-            rct_tile_element *mapElement = map_get_first_element_at(elemX >> 5, elemY >> 5);
+            rct_tile_element *tileElement = map_get_first_element_at(elemX >> 5, elemY >> 5);
             do
             {
-                if (mapElement->base_height != elemZ / 8)
+                if (tileElement->base_height != elemZ / 8)
                     continue;
 
-                if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                     continue;
 
-                if ((tile_element_get_direction(mapElement)) != rotation)
+                if ((tile_element_get_direction(tileElement)) != rotation)
                     continue;
 
-                if (tile_element_get_track_sequence(mapElement) != trackBlock->index)
+                if (tile_element_get_track_sequence(tileElement) != trackBlock->index)
                     continue;
 
-                if (mapElement->properties.track.type != type)
+                if (tileElement->properties.track.type != type)
                     continue;
 
                 found = true;
                 break;
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
 
             if (!found)
             {
@@ -691,8 +691,8 @@ sint32 tile_inspector_track_base_height_offset(sint32 x, sint32 y, sint32 elemen
             // Keep?
             //invalidate_test_results(rideIndex);
 
-            mapElement->base_height += offset;
-            mapElement->clearance_height += offset;
+            tileElement->base_height += offset;
+            tileElement->clearance_height += offset;
         }
     }
 
@@ -789,27 +789,27 @@ sint32 tile_inspector_track_set_chain(sint32 x, sint32 y, sint32 elementIndex, b
             map_invalidate_tile_full(elemX, elemY);
 
             bool found = false;
-            rct_tile_element *mapElement = map_get_first_element_at(elemX >> 5, elemY >> 5);
+            rct_tile_element *tileElement = map_get_first_element_at(elemX >> 5, elemY >> 5);
             do
             {
-                if (mapElement->base_height != elemZ / 8)
+                if (tileElement->base_height != elemZ / 8)
                     continue;
 
-                if (tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_TRACK)
+                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
                     continue;
 
-                if ((tile_element_get_direction(mapElement)) != rotation)
+                if ((tile_element_get_direction(tileElement)) != rotation)
                     continue;
 
-                if (tile_element_get_track_sequence(mapElement) != trackBlock->index)
+                if (tile_element_get_track_sequence(tileElement) != trackBlock->index)
                     continue;
 
-                if (mapElement->properties.track.type != type)
+                if (tileElement->properties.track.type != type)
                     continue;
 
                 found = true;
                 break;
-            } while (!tile_element_is_last_for_tile(mapElement++));
+            } while (!tile_element_is_last_for_tile(tileElement++));
 
             if (!found)
             {
@@ -823,9 +823,9 @@ sint32 tile_inspector_track_set_chain(sint32 x, sint32 y, sint32 elementIndex, b
             // Keep?
             //invalidate_test_results(rideIndex);
 
-            if (track_element_is_lift_hill(mapElement) != setChain)
+            if (track_element_is_lift_hill(tileElement) != setChain)
             {
-                mapElement->type ^= TRACK_ELEMENT_FLAG_CHAIN_LIFT;
+                tileElement->type ^= TRACK_ELEMENT_FLAG_CHAIN_LIFT;
             }
         }
     }
@@ -838,9 +838,9 @@ sint32 tile_inspector_track_set_chain(sint32 x, sint32 y, sint32 elementIndex, b
 
 sint32 tile_inspector_scenery_set_quarter_location(sint32 x, sint32 y, sint32 elementIndex, sint32 quarterIndex, sint32 flags)
 {
-    rct_tile_element *const mapElement = map_get_nth_element_at(x, y, elementIndex);
+    rct_tile_element *const tileElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (!mapElement || tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY)
+    if (!tileElement || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
     {
         return MONEY32_UNDEFINED;
     }
@@ -848,12 +848,12 @@ sint32 tile_inspector_scenery_set_quarter_location(sint32 x, sint32 y, sint32 el
     if (flags & GAME_COMMAND_FLAG_APPLY)
     {
         // Set quadrant index
-        mapElement->type &= ~TILE_ELEMENT_QUADRANT_MASK;
-        mapElement->type |= quarterIndex << 6;
+        tileElement->type &= ~TILE_ELEMENT_QUADRANT_MASK;
+        tileElement->type |= quarterIndex << 6;
 
         // Update collision
-        mapElement->flags &= 0xF0;
-        mapElement->flags |= 1 << ((quarterIndex + 2) & 3);
+        tileElement->flags &= 0xF0;
+        tileElement->flags |= 1 << ((quarterIndex + 2) & 3);
 
         map_invalidate_tile_full(x << 5, y << 5);
         if ((uint32)x == windowTileInspectorTileX && (uint32)y == windowTileInspectorTileY)
@@ -867,16 +867,16 @@ sint32 tile_inspector_scenery_set_quarter_location(sint32 x, sint32 y, sint32 el
 
 sint32 tile_inspector_scenery_set_quarter_collision(sint32 x, sint32 y, sint32 elementIndex, sint32 quarterIndex, sint32 flags)
 {
-    rct_tile_element *const mapElement = map_get_nth_element_at(x, y, elementIndex);
+    rct_tile_element *const tileElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (!mapElement || tile_element_get_type(mapElement) != TILE_ELEMENT_TYPE_SCENERY)
+    if (!tileElement || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SCENERY)
     {
         return MONEY32_UNDEFINED;
     }
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
     {
-        mapElement->flags ^= 1 << quarterIndex;
+        tileElement->flags ^= 1 << quarterIndex;
 
         map_invalidate_tile_full(x << 5, y << 5);
         if ((uint32)x == windowTileInspectorTileX && (uint32)y == windowTileInspectorTileY)
diff --git a/test/testpaint/TestTrack.cpp b/test/testpaint/TestTrack.cpp
index 09e6c58ce7..6961728ff6 100644
--- a/test/testpaint/TestTrack.cpp
+++ b/test/testpaint/TestTrack.cpp
@@ -46,7 +46,7 @@ public:
     virtual std::string VariantName(uint8 rideType, uint8 trackType, int variant) abstract;
 
     virtual void ApplyTo(uint8 rideType, uint8 trackType, int variant,
-                         rct_tile_element *mapElement, rct_tile_element *surfaceElement,
+                         rct_tile_element *tileElement, rct_tile_element *surfaceElement,
                          Ride *ride, rct_ride_entry *rideEntry
     ) abstract;
 };
@@ -66,13 +66,13 @@ public:
     }
 
     virtual void ApplyTo(uint8 rideType, uint8 trackType, int variant,
-                         rct_tile_element *mapElement, rct_tile_element *surfaceElement,
+                         rct_tile_element *tileElement, rct_tile_element *surfaceElement,
                          Ride *ride, rct_ride_entry *rideEntry
     ) override {
         if (variant == 0) {
-            mapElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
+            tileElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
         } else {
-            mapElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
+            tileElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
         }
     }
 };
@@ -92,13 +92,13 @@ public:
     }
 
     virtual void ApplyTo(uint8 rideType, uint8 trackType, int variant,
-                         rct_tile_element *mapElement, rct_tile_element *surfaceElement,
+                         rct_tile_element *tileElement, rct_tile_element *surfaceElement,
                          Ride *ride, rct_ride_entry *rideEntry
     ) override {
         if (variant == 0) {
-            mapElement->type &= ~TRACK_ELEMENT_FLAG_CHAIN_LIFT;
+            tileElement->type &= ~TRACK_ELEMENT_FLAG_CHAIN_LIFT;
         } else {
-            mapElement->type |= TRACK_ELEMENT_FLAG_CHAIN_LIFT;
+            tileElement->type |= TRACK_ELEMENT_FLAG_CHAIN_LIFT;
         }
     }
 };
@@ -124,13 +124,13 @@ public:
     }
 
     virtual void ApplyTo(uint8 rideType, uint8 trackType, int variant,
-                         rct_tile_element *mapElement, rct_tile_element *surfaceElement,
+                         rct_tile_element *tileElement, rct_tile_element *surfaceElement,
                          Ride *ride, rct_ride_entry *rideEntry
     ) override {
         if (variant == 0) {
-            mapElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
+            tileElement->properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
         } else {
-            mapElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
+            tileElement->properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
         }
     }
 };
@@ -156,7 +156,7 @@ public:
     }
 
     virtual void ApplyTo(uint8 rideType, uint8 trackType, int variant,
-                         rct_tile_element *mapElement, rct_tile_element *surfaceElement,
+                         rct_tile_element *tileElement, rct_tile_element *surfaceElement,
                          Ride *ride, rct_ride_entry *rideEntry
     ) override {
         ride->entrance_style = variant;
@@ -171,7 +171,7 @@ static void CallOriginal(
     uint8 direction,
     uint8 trackSequence,
     uint16 height,
-    rct_tile_element *mapElement
+    rct_tile_element *tileElement
 ) {
     uint32 *trackDirectionList = (uint32 *) RideTypeTrackPaintFunctionsOld[rideType][trackType];
     const uint8 rideIndex = 0;
@@ -183,7 +183,7 @@ static void CallOriginal(
         (int) trackDirectionList,
         direction,
         height,
-        (int) mapElement,
+        (int) tileElement,
         rideIndex * sizeof(Ride),
         trackSequence
     );
@@ -195,12 +195,12 @@ static void CallNew(
     uint8 direction,
     uint8 trackSequence,
     uint16 height,
-    rct_tile_element *mapElement
+    rct_tile_element *tileElement
 ) {
     TRACK_PAINT_FUNCTION_GETTER newPaintFunctionGetter = RideTypeTrackPaintFunctions[rideType];
     TRACK_PAINT_FUNCTION newPaintFunction = newPaintFunctionGetter(trackType, direction);
 
-    newPaintFunction(&gPaintSession, 0, trackSequence, direction, height, mapElement);
+    newPaintFunction(&gPaintSession, 0, trackSequence, direction, height, tileElement);
 }
 
 typedef uint8 (*TestFunction)(uint8, uint8, uint8, std::string *);
@@ -258,11 +258,11 @@ uint8 TestTrack::TestPaintTrackElement(uint8 rideType, uint8 trackType, std::str
 static uint8 TestTrackElementPaintCalls(uint8 rideType, uint8 trackType, uint8 trackSequence, std::string *error) {
     uint16 height = 3 * 16;
 
-    rct_tile_element mapElement = {0};
-    mapElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
-    mapElement.properties.track.type = trackType;
-    mapElement.base_height = height / 16;
-    g_currently_drawn_item = &mapElement;
+    rct_tile_element tileElement = {0};
+    tileElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+    tileElement.properties.track.type = trackType;
+    tileElement.base_height = height / 16;
+    g_currently_drawn_item = &tileElement;
 
     rct_tile_element surfaceElement = {0};
     surfaceElement.type = TILE_ELEMENT_TYPE_SURFACE;
@@ -270,7 +270,7 @@ static uint8 TestTrackElementPaintCalls(uint8 rideType, uint8 trackType, uint8 t
     gSurfaceElement = &surfaceElement;
     gDidPassSurface = true;
 
-    gPaintSession.CurrentlyDrawnItem = &mapElement;
+    gPaintSession.CurrentlyDrawnItem = &tileElement;
     gPaintSession.SurfaceElement = &surfaceElement;
     gPaintSession.DidPassSurface = true;
 
@@ -333,7 +333,7 @@ static uint8 TestTrackElementPaintCalls(uint8 rideType, uint8 trackType, uint8 t
             baseCaseName += activeFilters[filterIndex]->VariantName(rideType, trackType, variant);
             baseCaseName += " ";
 
-            activeFilters[filterIndex]->ApplyTo(rideType, trackType, variant, &mapElement, &surfaceElement, &(gRideList[0]), gRideEntries[0]);
+            activeFilters[filterIndex]->ApplyTo(rideType, trackType, variant, &tileElement, &surfaceElement, &(gRideList[0]), gRideEntries[0]);
         }
 
 
@@ -352,7 +352,7 @@ static uint8 TestTrackElementPaintCalls(uint8 rideType, uint8 trackType, uint8 t
                 TestPaint::ResetSupportHeights();
                 gWoodenSupportsPrependTo = nullptr;
 
-                CallOriginal(rideType, trackType, direction, trackSequence, height, &mapElement);
+                CallOriginal(rideType, trackType, direction, trackSequence, height, &tileElement);
 
                 callCount = PaintIntercept::GetCalls(callBuffer);
                 std::vector<function_call> oldCalls;
@@ -363,7 +363,7 @@ static uint8 TestTrackElementPaintCalls(uint8 rideType, uint8 trackType, uint8 t
                 TestPaint::ResetSupportHeights();
                 gPaintSession.WoodenSupportsPrependTo = nullptr;
 
-                CallNew(rideType, trackType, direction, trackSequence, height, &mapElement);
+                CallNew(rideType, trackType, direction, trackSequence, height, &tileElement);
 
                 if (testpaint_is_ignored(direction, trackSequence)) {
                     *error += String::Format("[  IGNORED ]   %s\n", caseName.c_str());
@@ -404,11 +404,11 @@ static uint8 TestTrackElementPaintCalls(uint8 rideType, uint8 trackType, uint8 t
 static uint8 TestTrackElementSegmentSupportHeight(uint8 rideType, uint8 trackType, uint8 trackSequence, std::string *error) {
     uint16 height = 3 * 16;
 
-    rct_tile_element mapElement = {0};
-    mapElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
-    mapElement.properties.track.type = trackType;
-    mapElement.base_height = height / 16;
-    g_currently_drawn_item = &mapElement;
+    rct_tile_element tileElement = {0};
+    tileElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+    tileElement.properties.track.type = trackType;
+    tileElement.base_height = height / 16;
+    g_currently_drawn_item = &tileElement;
     
     rct_tile_element surfaceElement = {0};
     surfaceElement.type = TILE_ELEMENT_TYPE_SURFACE;
@@ -416,7 +416,7 @@ static uint8 TestTrackElementSegmentSupportHeight(uint8 rideType, uint8 trackTyp
     gSurfaceElement = &surfaceElement;
     gDidPassSurface = true;
 
-    gPaintSession.CurrentlyDrawnItem = &mapElement;
+    gPaintSession.CurrentlyDrawnItem = &tileElement;
     gPaintSession.SurfaceElement = &surfaceElement;
     gPaintSession.DidPassSurface = true;
 
@@ -434,7 +434,7 @@ static uint8 TestTrackElementSegmentSupportHeight(uint8 rideType, uint8 trackTyp
     for (int direction = 0; direction < 4; direction++) {
         TestPaint::ResetSupportHeights();
 
-        CallOriginal(rideType, trackType, direction, trackSequence, height, &mapElement);
+        CallOriginal(rideType, trackType, direction, trackSequence, height, &tileElement);
 
         tileSegmentSupportCalls[direction] = SegmentSupportHeightCall::getSegmentCalls(gSupportSegments, direction);
     }
@@ -457,7 +457,7 @@ static uint8 TestTrackElementSegmentSupportHeight(uint8 rideType, uint8 trackTyp
         TestPaint::ResetSupportHeights();
 
         testpaint_clear_ignore();
-        CallNew(rideType, trackType, direction, trackSequence, height, &mapElement);
+        CallNew(rideType, trackType, direction, trackSequence, height, &tileElement);
         if (testpaint_is_ignored(direction, trackSequence)) {
             continue;
         }
@@ -483,11 +483,11 @@ static uint8 TestTrackElementSegmentSupportHeight(uint8 rideType, uint8 trackTyp
 static uint8 TestTrackElementGeneralSupportHeight(uint8 rideType, uint8 trackType, uint8 trackSequence, std::string *error) {
     uint16 height = 3 * 16;
 
-    rct_tile_element mapElement = {0};
-    mapElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
-    mapElement.properties.track.type = trackType;
-    mapElement.base_height = height / 16;
-    g_currently_drawn_item = &mapElement;
+    rct_tile_element tileElement = {0};
+    tileElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+    tileElement.properties.track.type = trackType;
+    tileElement.base_height = height / 16;
+    g_currently_drawn_item = &tileElement;
 
     rct_tile_element surfaceElement = {0};
     surfaceElement.type = TILE_ELEMENT_TYPE_SURFACE;
@@ -495,7 +495,7 @@ static uint8 TestTrackElementGeneralSupportHeight(uint8 rideType, uint8 trackTyp
     gSurfaceElement = &surfaceElement;
     gDidPassSurface = true;
 
-    gPaintSession.CurrentlyDrawnItem = &mapElement;
+    gPaintSession.CurrentlyDrawnItem = &tileElement;
     gPaintSession.SurfaceElement = &surfaceElement;
     gPaintSession.DidPassSurface = true;
 
@@ -512,7 +512,7 @@ static uint8 TestTrackElementGeneralSupportHeight(uint8 rideType, uint8 trackTyp
     for (int direction = 0; direction < 4; direction++) {
         TestPaint::ResetSupportHeights();
 
-        CallOriginal(rideType, trackType, direction, trackSequence, height, &mapElement);
+        CallOriginal(rideType, trackType, direction, trackSequence, height, &tileElement);
 
         tileGeneralSupportCalls[direction].height = -1;
         tileGeneralSupportCalls[direction].slope = -1;
@@ -541,7 +541,7 @@ static uint8 TestTrackElementGeneralSupportHeight(uint8 rideType, uint8 trackTyp
         TestPaint::ResetSupportHeights();
 
         testpaint_clear_ignore();
-        CallNew(rideType, trackType, direction, trackSequence, height, &mapElement);
+        CallNew(rideType, trackType, direction, trackSequence, height, &tileElement);
         if (testpaint_is_ignored(direction, trackSequence)) {
             continue;
         }
@@ -579,11 +579,11 @@ static uint8 TestTrackElementGeneralSupportHeight(uint8 rideType, uint8 trackTyp
 static uint8 TestTrackElementSideTunnels(uint8 rideType, uint8 trackType, uint8 trackSequence, std::string *error) {
     uint16 height = 3 * 16;
 
-    rct_tile_element mapElement = {0};
-    mapElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
-    mapElement.properties.track.type = trackType;
-    mapElement.base_height = height / 16;
-    g_currently_drawn_item = &mapElement;
+    rct_tile_element tileElement = {0};
+    tileElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+    tileElement.properties.track.type = trackType;
+    tileElement.base_height = height / 16;
+    g_currently_drawn_item = &tileElement;
 
     rct_tile_element surfaceElement = {0};
     surfaceElement.type = TILE_ELEMENT_TYPE_SURFACE;
@@ -591,7 +591,7 @@ static uint8 TestTrackElementSideTunnels(uint8 rideType, uint8 trackType, uint8
     gSurfaceElement = &surfaceElement;
     gDidPassSurface = true;
 
-    gPaintSession.CurrentlyDrawnItem = &mapElement;
+    gPaintSession.CurrentlyDrawnItem = &tileElement;
     gPaintSession.SurfaceElement = &surfaceElement;
     gPaintSession.DidPassSurface = true;
 
@@ -606,7 +606,7 @@ static uint8 TestTrackElementSideTunnels(uint8 rideType, uint8 trackType, uint8
         TestPaint::ResetTunnels();
 
         for (sint8 offset = -8; offset <= 8; offset += 8) {
-            CallOriginal(rideType, trackType, direction, trackSequence, height + offset, &mapElement);
+            CallOriginal(rideType, trackType, direction, trackSequence, height + offset, &tileElement);
         }
 
         uint8 rightIndex = (direction + 1) % 4;
@@ -637,7 +637,7 @@ static uint8 TestTrackElementSideTunnels(uint8 rideType, uint8 trackType, uint8
 
         for (sint8 offset = -8; offset <= 8; offset += 8) {
             // TODO: move tunnel pushing to interface so we don't have to check the output 3 times
-            CallNew(rideType, trackType, direction, trackSequence, height + offset, &mapElement);
+            CallNew(rideType, trackType, direction, trackSequence, height + offset, &tileElement);
         }
 
         uint8 rightIndex = (direction + 1) % 4;
@@ -695,11 +695,11 @@ static uint8 TestTrackElementSideTunnels(uint8 rideType, uint8 trackType, uint8
 static uint8 TestTrackElementVerticalTunnels(uint8 rideType, uint8 trackType, uint8 trackSequence, std::string *error) {
     uint16 height = 3 * 16;
 
-    rct_tile_element mapElement = {0};
-    mapElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
-    mapElement.properties.track.type = trackType;
-    mapElement.base_height = height / 16;
-    g_currently_drawn_item = &mapElement;
+    rct_tile_element tileElement = {0};
+    tileElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+    tileElement.properties.track.type = trackType;
+    tileElement.base_height = height / 16;
+    g_currently_drawn_item = &tileElement;
 
     rct_tile_element surfaceElement = {0};
     surfaceElement.type = TILE_ELEMENT_TYPE_SURFACE;
@@ -707,7 +707,7 @@ static uint8 TestTrackElementVerticalTunnels(uint8 rideType, uint8 trackType, ui
     gSurfaceElement = &surfaceElement;
     gDidPassSurface = true;
 
-    gPaintSession.CurrentlyDrawnItem = &mapElement;
+    gPaintSession.CurrentlyDrawnItem = &tileElement;
     gPaintSession.SurfaceElement = &surfaceElement;
     gPaintSession.DidPassSurface = true;
 
@@ -721,7 +721,7 @@ static uint8 TestTrackElementVerticalTunnels(uint8 rideType, uint8 trackType, ui
 
         for (uint8 i = 0; i < 3; i++) {
             gVerticalTunnelHeight = 0;
-            CallOriginal(rideType, trackType, direction, trackSequence, height - 8 + i * 8, &mapElement);
+            CallOriginal(rideType, trackType, direction, trackSequence, height - 8 + i * 8, &tileElement);
             tunnelHeights[i] = gVerticalTunnelHeight;
         }
 
@@ -743,7 +743,7 @@ static uint8 TestTrackElementVerticalTunnels(uint8 rideType, uint8 trackType, ui
         testpaint_clear_ignore();
 
         testPaintVerticalTunnelHeight = 0;
-        CallNew(rideType, trackType, direction, trackSequence, height, &mapElement);
+        CallNew(rideType, trackType, direction, trackSequence, height, &tileElement);
 
         if (testpaint_is_ignored(direction, trackSequence)) {
             continue;
diff --git a/test/testpaint/compat.c b/test/testpaint/compat.c
index 1b6ffd1696..66655eca60 100644
--- a/test/testpaint/compat.c
+++ b/test/testpaint/compat.c
@@ -29,8 +29,8 @@
 #define gRideEntries                RCT2_ADDRESS(RCT2_ADDRESS_RIDE_ENTRIES,                rct_ride_entry*)
 #define gCurrentRotation        RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_ROTATION, uint8)
 
-rct_tile_element *gMapElements = (rct_tile_element *) RCT2_ADDRESS_TILE_ELEMENTS;
-rct_tile_element **gMapElementTilePointers = (rct_tile_element **) RCT2_ADDRESS_TILE_TILE_ELEMENT_POINTERS;
+rct_tile_element *gTileElements = (rct_tile_element *) RCT2_ADDRESS_TILE_ELEMENTS;
+rct_tile_element **gTileElementTilePointers = (rct_tile_element **) RCT2_ADDRESS_TILE_TILE_ELEMENT_POINTERS;
 Ride *gRideList = RCT2_ADDRESS(RCT2_ADDRESS_RIDE_LIST, Ride);
 rct_sprite *sprite_list = RCT2_ADDRESS(RCT2_ADDRESS_SPRITE_LIST, rct_sprite);
 sint16 gMapSizeUnits;
@@ -83,11 +83,11 @@ uint8 gMapSelectArrowDirection;
 
 void entrance_paint(paint_session * session, uint8 direction, int height, rct_tile_element *tile_element) { }
 void banner_paint(paint_session * session, uint8 direction, int height, rct_tile_element *tile_element) { }
-void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement) { }
-void path_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement) { }
-void scenery_paint(paint_session * session, uint8 direction, int height, rct_tile_element *mapElement) { }
-void fence_paint(paint_session * session, uint8 direction, int height, rct_tile_element *mapElement) { }
-void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *mapElement) { }
+void surface_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement) { }
+void path_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement) { }
+void scenery_paint(paint_session * session, uint8 direction, int height, rct_tile_element *tileElement) { }
+void fence_paint(paint_session * session, uint8 direction, int height, rct_tile_element *tileElement) { }
+void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 height, rct_tile_element *tileElement) { }
 
 Ride *get_ride(int index) {
     if (index < 0 || index >= MAX_RIDES) {
@@ -140,77 +140,77 @@ rct_tile_element *map_get_first_element_at(int x, int y) {
         log_error("Trying to access element outside of range");
         return NULL;
     }
-    return gMapElementTilePointers[x + y * 256];
+    return gTileElementTilePointers[x + y * 256];
 }
 
-int tile_element_get_station(const rct_tile_element * mapElement) {
-    return (mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_STATION_INDEX_MASK) >> 4;
+int tile_element_get_station(const rct_tile_element * tileElement) {
+    return (tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_STATION_INDEX_MASK) >> 4;
 }
 
-void tile_element_set_station(rct_tile_element * mapElement, uint32 stationIndex)
+void tile_element_set_station(rct_tile_element * tileElement, uint32 stationIndex)
 {
-    mapElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_STATION_INDEX_MASK;
-    mapElement->properties.track.sequence |= (stationIndex << 4);
+    tileElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_STATION_INDEX_MASK;
+    tileElement->properties.track.sequence |= (stationIndex << 4);
 }
 
-sint32 tile_element_get_track_sequence(const rct_tile_element * mapElement)
+sint32 tile_element_get_track_sequence(const rct_tile_element * tileElement)
 {
-    return mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
+    return tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
 }
 
-void tile_element_set_track_sequence(rct_tile_element * mapElement, int trackSequence)
+void tile_element_set_track_sequence(rct_tile_element * tileElement, int trackSequence)
 {
-    mapElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
-    mapElement->properties.track.sequence |= (trackSequence & MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK);
+    tileElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
+    tileElement->properties.track.sequence |= (trackSequence & MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK);
 }
 
-bool tile_element_get_green_light(const rct_tile_element * mapElement)
+bool tile_element_get_green_light(const rct_tile_element * tileElement)
 {
-    return (mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT) != 0;
+    return (tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT) != 0;
 }
 
-void tile_element_set_green_light(rct_tile_element * mapElement, bool greenLight)
+void tile_element_set_green_light(rct_tile_element * tileElement, bool greenLight)
 {
-    mapElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
+    tileElement->properties.track.sequence &= ~MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
     if (greenLight)
     {
-        mapElement->properties.track.sequence |= MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
+        tileElement->properties.track.sequence |= MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT;
     }
 }
 
-int tile_element_get_brake_booster_speed(const rct_tile_element *mapElement)
+int tile_element_get_brake_booster_speed(const rct_tile_element *tileElement)
 {
-    return (mapElement->properties.track.sequence >> 4) << 1;
+    return (tileElement->properties.track.sequence >> 4) << 1;
 }
 
-void tile_element_set_brake_booster_speed(rct_tile_element *mapElement, int speed)
+void tile_element_set_brake_booster_speed(rct_tile_element *tileElement, int speed)
 {
-    mapElement->properties.track.sequence = tile_element_get_track_sequence(mapElement) | ((speed >> 1) << 4);
+    tileElement->properties.track.sequence = tile_element_get_track_sequence(tileElement) | ((speed >> 1) << 4);
 }
 
-bool tile_element_is_taking_photo(const rct_tile_element * mapElement)
+bool tile_element_is_taking_photo(const rct_tile_element * tileElement)
 {
-    return (mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK) != 0;
+    return (tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK) != 0;
 }
 
-void tile_element_set_onride_photo_timeout(rct_tile_element * mapElement)
+void tile_element_set_onride_photo_timeout(rct_tile_element * tileElement)
 {
-    mapElement->properties.track.sequence &= MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
-    mapElement->properties.track.sequence |= (3 << 4);
+    tileElement->properties.track.sequence &= MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK;
+    tileElement->properties.track.sequence |= (3 << 4);
 }
 
-void tile_element_decrement_onride_photo_timout(rct_tile_element * mapElement)
+void tile_element_decrement_onride_photo_timout(rct_tile_element * tileElement)
 {
     // We should only touch the upper 4 bits, avoid underflow into the lower 4.
-    if (mapElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK)
+    if (tileElement->properties.track.sequence & MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK)
     {
-        mapElement->properties.track.sequence -= (1 << 4);
+        tileElement->properties.track.sequence -= (1 << 4);
     }
 }
 
-sint32 map_get_water_height(const rct_tile_element * mapElement)
+sint32 map_get_water_height(const rct_tile_element * tileElement)
 {
-    return mapElement->properties.surface.terrain & TILE_ELEMENT_WATER_HEIGHT_MASK;
+    return tileElement->properties.surface.terrain & TILE_ELEMENT_WATER_HEIGHT_MASK;
 }
 
 bool ride_type_has_flag(int rideType, int flag)
@@ -243,7 +243,7 @@ bool is_csg_loaded()
     return false;
 }
 
-uint8 track_element_get_colour_scheme(const rct_tile_element * mapElement)
+uint8 track_element_get_colour_scheme(const rct_tile_element * tileElement)
 {
-    return mapElement->properties.track.colour & 0x3;
+    return tileElement->properties.track.colour & 0x3;
 }
diff --git a/test/testpaint/generate.cpp b/test/testpaint/generate.cpp
index f3ca8dac51..fa6e85e66a 100644
--- a/test/testpaint/generate.cpp
+++ b/test/testpaint/generate.cpp
@@ -137,7 +137,7 @@ private:
             {
                 const uint32 * paintFunctionList = RideTypeTrackPaintFunctionsOld[_rideType];
                 WriteLine(0, "/** rct2: 0x%08X, 0x%08X, 0x%08X */", paintFunctionList[TRACK_ELEM_END_STATION], paintFunctionList[TRACK_ELEM_BEGIN_STATION], paintFunctionList[TRACK_ELEM_MIDDLE_STATION]);
-                WriteLine(0, "static void " + _rideName + "_track_station(uint8 rideIndex, uint8 trackSequence, uint8 direction, int height, rct_tile_element * mapElement)");
+                WriteLine(0, "static void " + _rideName + "_track_station(uint8 rideIndex, uint8 trackSequence, uint8 direction, int height, rct_tile_element * tileElement)");
                 WriteLine(0, "{");
                 WriteLine(0, "}");
                 WriteLine();
@@ -148,7 +148,7 @@ private:
     void GenerateTrackFunction(int trackType)
     {
         WriteLine(0, "/** rct2: 0x%08X */", RideTypeTrackPaintFunctionsOld[_rideType][trackType]);
-        WriteLine(0, "static void " + GetTrackFunctionName(trackType) + "(uint8 rideIndex, uint8 trackSequence, uint8 direction, int height, rct_tile_element * mapElement)");
+        WriteLine(0, "static void " + GetTrackFunctionName(trackType) + "(uint8 rideIndex, uint8 trackSequence, uint8 direction, int height, rct_tile_element * tileElement)");
         WriteLine(0, "{");
         if (!GenerateMirrorCall(1, trackType))
         {
@@ -156,7 +156,7 @@ private:
                 _rideType == RIDE_TYPE_FLYING_ROLLER_COASTER ||
                 _rideType == RIDE_TYPE_LAY_DOWN_ROLLER_COASTER)
             {
-                WriteLine(1, "if (!track_element_is_inverted(mapElement)) {");
+                WriteLine(1, "if (!track_element_is_inverted(tileElement)) {");
                 _invertedTrack = false;
                 GenerateTrackFunctionBody(2, trackType);
                 WriteLine(1, "} else {");
@@ -289,37 +289,37 @@ private:
                 std::string destFuncName = GetTrackFunctionName(mirrorTable[i][2]);
                 switch (mirrorTable[i][0]) {
                 case 0:
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 1:
                     WriteLine(tabs, "trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 2:
                     WriteLine(tabs, "trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 3:
                     WriteLine(tabs, "trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 4:
                     WriteLine(tabs, "trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 5:
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 6:
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 7:
                     WriteLine(tabs, "trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 3) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 8:
                     WriteLine(tabs, "trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 2) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 9:
                     WriteLine(tabs, "if (trackSequence >= 4) {");
@@ -327,7 +327,7 @@ private:
                     WriteLine(tabs + 1, "direction = (direction + 1) & 3;");
                     WriteLine(tabs, "}");
                     WriteLine(tabs, "trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 10:
                     WriteLine(tabs, "if (trackSequence >= 4) {");
@@ -335,7 +335,7 @@ private:
                     WriteLine(tabs + 1, "direction = (direction - 1) & 3;");
                     WriteLine(tabs, "}");
                     WriteLine(tabs, "trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 11:
                     WriteLine(tabs, "if (trackSequence >= 7) {");
@@ -343,7 +343,7 @@ private:
                     WriteLine(tabs + 1, "direction = (direction + 1) & 3;");
                     WriteLine(tabs, "}");
                     WriteLine(tabs, "trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 12:
                     WriteLine(tabs, "if (trackSequence >= 7) {");
@@ -351,28 +351,28 @@ private:
                     WriteLine(tabs + 1, "direction = (direction - 1) & 3;");
                     WriteLine(tabs, "}");
                     WriteLine(tabs, "trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];");
-                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 13:
-                    WriteLine(tabs, "%s(rideIndex, 3 - trackSequence, (direction + 2) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, 3 - trackSequence, (direction + 2) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 14:
-                    WriteLine(tabs, "%s(rideIndex, 2 - trackSequence, (direction - 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 15:
-                    WriteLine(tabs, "%s(rideIndex, 2 - trackSequence, (direction + 1) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, 2 - trackSequence, (direction + 1) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 16:
-                    WriteLine(tabs, "%s(rideIndex, 3 - trackSequence, direction, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, 3 - trackSequence, direction, height, tileElement);", destFuncName.c_str());
                     break;
                 case 17:
-                    WriteLine(tabs, "%s(rideIndex, 2 - trackSequence, direction, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, 2 - trackSequence, direction, height, tileElement);", destFuncName.c_str());
                     break;
                 case 18:
-                    WriteLine(tabs, "%s(rideIndex, 2 - trackSequence, (direction + 2) & 3, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, 2 - trackSequence, (direction + 2) & 3, height, tileElement);", destFuncName.c_str());
                     break;
                 case 19:
-                    WriteLine(tabs, "%s(rideIndex, 6 - trackSequence, direction, height, mapElement);", destFuncName.c_str());
+                    WriteLine(tabs, "%s(rideIndex, 6 - trackSequence, direction, height, tileElement);", destFuncName.c_str());
                     break;
                 }
                 return true;
@@ -405,15 +405,15 @@ private:
         std::vector<SegmentSupportCall> segmentSupportCalls[4];
         support_height generalSupports[4] = { 0 };
         for (int direction = 0; direction < 4; direction++) {
-            rct_tile_element mapElement = { 0 };
-            mapElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
-            mapElement.properties.track.type = trackType;
-            mapElement.base_height = 3;
+            rct_tile_element tileElement = { 0 };
+            tileElement.flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+            tileElement.properties.track.type = trackType;
+            tileElement.base_height = 3;
             if (_invertedTrack)
             {
-                mapElement.properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
+                tileElement.properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_INVERTED;
             }
-            g_currently_drawn_item = &mapElement;
+            g_currently_drawn_item = &tileElement;
 
             // Set position
             RCT2_GLOBAL(0x009DE56A, sint16) = 64;
@@ -421,7 +421,7 @@ private:
 
             function_call callBuffer[256] = { 0 };
             PaintIntercept::ClearCalls();
-            CallOriginal(trackType, direction, trackSequence, height, &mapElement);
+            CallOriginal(trackType, direction, trackSequence, height, &tileElement);
             int numCalls = PaintIntercept::GetCalls(callBuffer);
             calls[direction].insert(calls[direction].begin(), callBuffer, callBuffer + numCalls);
 
@@ -440,19 +440,19 @@ private:
             }
 
             // Get chain lift calls
-            mapElement.type |= 0x80;
+            tileElement.type |= 0x80;
             PaintIntercept::ClearCalls();
-            CallOriginal(trackType, direction, trackSequence, height, &mapElement);
+            CallOriginal(trackType, direction, trackSequence, height, &tileElement);
             numCalls = PaintIntercept::GetCalls(callBuffer);
             chainLiftCalls[direction].insert(chainLiftCalls[direction].begin(), callBuffer, callBuffer + numCalls);
 
             // Get cable lift calls (giga coaster only)
             if (_rideType == RIDE_TYPE_GIGA_COASTER)
             {
-                mapElement.type = 0;
-                mapElement.properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
+                tileElement.type = 0;
+                tileElement.properties.track.colour |= TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
                 PaintIntercept::ClearCalls();
-                CallOriginal(trackType, direction, trackSequence, height, &mapElement);
+                CallOriginal(trackType, direction, trackSequence, height, &tileElement);
                 numCalls = PaintIntercept::GetCalls(callBuffer);
                 cableLiftCalls[direction].insert(cableLiftCalls[direction].begin(), callBuffer, callBuffer + numCalls);
             }
@@ -462,10 +462,10 @@ private:
             {
                 RCT2_GLOBAL(0x009DE56A, sint16) = 64 + 32;
                 RCT2_GLOBAL(0x009DE56E, sint16) = 64;
-                mapElement.type = 0;
-                mapElement.properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
+                tileElement.type = 0;
+                tileElement.properties.track.colour &= ~TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT;
                 PaintIntercept::ClearCalls();
-                CallOriginal(trackType, direction, trackSequence, height, &mapElement);
+                CallOriginal(trackType, direction, trackSequence, height, &tileElement);
                 numCalls = PaintIntercept::GetCalls(callBuffer);
                 std::vector<function_call> checkCalls = std::vector<function_call>(callBuffer, callBuffer + numCalls);
                 if (!CompareFunctionCalls(checkCalls, calls[direction]))
@@ -474,7 +474,7 @@ private:
                 }
             }
 
-            GetTunnelCalls(trackType, direction, trackSequence, height, &mapElement, tileTunnelCalls, verticalTunnelHeights);
+            GetTunnelCalls(trackType, direction, trackSequence, height, &tileElement, tileTunnelCalls, verticalTunnelHeights);
         }
 
         std::vector<function_call> supportCalls[4], chainLiftSupportCalls[4], cableLiftSupportCalls[4];
@@ -486,12 +486,12 @@ private:
 
         if (_rideType == RIDE_TYPE_GIGA_COASTER && !CompareFunctionCalls(calls, cableLiftCalls))
         {
-            WriteLine(tabs, "if (track_element_is_cable_lift(mapElement)) {");
+            WriteLine(tabs, "if (track_element_is_cable_lift(tileElement)) {");
             GenerateCalls(tabs + 1, cableLiftCalls, height);
 
             if (!CompareFunctionCalls(calls, chainLiftCalls))
             {
-                WriteLine(tabs, "} else if (track_element_is_lift_hill(mapElement)) {");
+                WriteLine(tabs, "} else if (track_element_is_lift_hill(tileElement)) {");
                 GenerateCalls(tabs + 1, chainLiftCalls, height);
             }
 
@@ -501,7 +501,7 @@ private:
         }
         else if (!CompareFunctionCalls(calls, chainLiftCalls))
         {
-            WriteLine(tabs, "if (track_element_is_lift_hill(mapElement)) {");
+            WriteLine(tabs, "if (track_element_is_lift_hill(tileElement)) {");
             GenerateCalls(tabs + 1, chainLiftCalls, height);
             WriteLine(tabs, "} else {");
             GenerateCalls(tabs + 1, calls, height);
@@ -736,7 +736,7 @@ private:
                         int direction,
                         int trackSequence,
                         int height,
-                        rct_tile_element * mapElement,
+                        rct_tile_element * tileElement,
                         TunnelCall tileTunnelCalls[4][4],
                         sint16 verticalTunnelHeights[4])
     {
@@ -744,7 +744,7 @@ private:
 
         for (int offset = -8; offset <= 8; offset += 8)
         {
-            CallOriginal(trackType, direction, trackSequence, height + offset, mapElement);
+            CallOriginal(trackType, direction, trackSequence, height + offset, tileElement);
         }
 
         uint8 rightIndex = (4 - direction) % 4;
@@ -777,7 +777,7 @@ private:
 
         // Vertical tunnel
         gVerticalTunnelHeight = 0;
-        CallOriginal(trackType, direction, trackSequence, height, mapElement);
+        CallOriginal(trackType, direction, trackSequence, height, tileElement);
 
         int verticalTunnelHeight = gVerticalTunnelHeight;
         if (verticalTunnelHeight != 0)
@@ -1005,7 +1005,7 @@ private:
         return true;
     }
 
-    void CallOriginal(int trackType, int direction, int trackSequence, int height, rct_tile_element *mapElement)
+    void CallOriginal(int trackType, int direction, int trackSequence, int height, rct_tile_element *tileElement)
     {
         TestPaint::ResetEnvironment();
         TestPaint::ResetSupportHeights();
@@ -1018,7 +1018,7 @@ private:
             (int) trackDirectionList,
             direction,
             height,
-            (int)mapElement,
+            (int)tileElement,
             0 * sizeof(Ride),
             trackSequence
         );