diff --git a/src/openrct2-ui/windows/Banner.cpp b/src/openrct2-ui/windows/Banner.cpp
index b94e899254..9dd0d3860b 100644
--- a/src/openrct2-ui/windows/Banner.cpp
+++ b/src/openrct2-ui/windows/Banner.cpp
@@ -148,7 +148,7 @@ rct_window * window_banner_open(rct_windownumber number)
     rct_tile_element* tile_element = map_get_first_element_at(view_x / 32, view_y / 32);
     while(1) {
         if (
-            (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_BANNER) &&
+            (tile_element->GetType() == TILE_ELEMENT_TYPE_BANNER) &&
             (tile_element->properties.banner.index == w->number)
         ) {
             break;
@@ -198,7 +198,7 @@ static void window_banner_mouseup(rct_window *w, rct_widgetindex widgetIndex)
     rct_tile_element* tile_element = map_get_first_element_at(x / 32, y / 32);
 
     while (1){
-        if ((tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_BANNER) &&
+        if ((tile_element->GetType() == TILE_ELEMENT_TYPE_BANNER) &&
             (tile_element->properties.banner.index == w->number)) break;
         tile_element++;
     }
diff --git a/src/openrct2-ui/windows/Footpath.cpp b/src/openrct2-ui/windows/Footpath.cpp
index 8db815c178..83acdd9356 100644
--- a/src/openrct2-ui/windows/Footpath.cpp
+++ b/src/openrct2-ui/windows/Footpath.cpp
@@ -860,7 +860,7 @@ static void window_footpath_set_selection_start_bridge_at_point(sint32 screenX,
 
     sint32 z = tileElement->base_height;
 
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_SURFACE)
     {
         uint8 slope = tileElement->properties.surface.slope;
         if (slope & TILE_ELEMENT_SLOPE_ALL_CORNERS_UP)
@@ -949,7 +949,7 @@ static void window_footpath_start_bridge_at_point(sint32 screenX, sint32 screenY
         return;
     }
 
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
+    if (tileElement->GetType() == 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.
@@ -969,7 +969,7 @@ static void window_footpath_start_bridge_at_point(sint32 screenX, sint32 screenY
     else
     {
         z = tileElement->base_height;
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)
         {
             if (tileElement->properties.path.type & 4)
             {
@@ -1130,7 +1130,7 @@ static rct_tile_element * footpath_get_tile_element_to_remove()
     tileElement = map_get_first_element_at(x, y);
     do
     {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)
         {
             if (tileElement->base_height == z)
             {
diff --git a/src/openrct2-ui/windows/Map.cpp b/src/openrct2-ui/windows/Map.cpp
index 287f75137a..ed01e94642 100644
--- a/src/openrct2-ui/windows/Map.cpp
+++ b/src/openrct2-ui/windows/Map.cpp
@@ -1291,7 +1291,7 @@ static void window_map_set_peep_spawn_tool_update(sint32 x, sint32 y)
         return;
 
     mapZ = tileElement->base_height * 8;
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE) {
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_SURFACE) {
         if ((tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_ALL_CORNERS_UP) != 0)
             mapZ += 16;
         if (tileElement->properties.surface.slope & TILE_ELEMENT_SLOPE_DOUBLE_HEIGHT)
@@ -1569,7 +1569,7 @@ static uint16 map_window_get_pixel_colour_peep(CoordsXY c)
 
     const sint32 maxSupportedTileElementType = (sint32)Util::CountOf(ElementTypeAddColour);
     while (!tile_element_is_last_for_tile(tileElement++)) {
-        sint32 tileElementType = tile_element_get_type(tileElement) >> 2;
+        sint32 tileElementType = tileElement->GetType() >> 2;
         if (tileElementType >= maxSupportedTileElementType) {
             tileElementType = TILE_ELEMENT_TYPE_CORRUPT >> 2;
         }
@@ -1589,7 +1589,7 @@ static uint16 map_window_get_pixel_colour_ride(CoordsXY c)
     // as an improvement we could use first_element to show underground stuff?
     rct_tile_element * tileElement = map_get_surface_element_at(c);
     do {
-        switch (tile_element_get_type(tileElement)) {
+        switch (tileElement->GetType()) {
         case TILE_ELEMENT_TYPE_SURFACE:
             if (surface_get_water_height(tileElement) > 0)
                 // Why is this a different water colour as above (195)?
diff --git a/src/openrct2-ui/windows/Ride.cpp b/src/openrct2-ui/windows/Ride.cpp
index 799a54bebe..429fa94b44 100644
--- a/src/openrct2-ui/windows/Ride.cpp
+++ b/src/openrct2-ui/windows/Ride.cpp
@@ -1456,7 +1456,7 @@ static void window_ride_update_overall_view(uint8 ride_index) {
     sint32 maxx = std::numeric_limits<sint32>::min(), maxy = std::numeric_limits<sint32>::min(), maxz = std::numeric_limits<sint32>::min();
 
     while (tile_element_iterator_next(&it)) {
-        if (tile_element_get_type(it.element) != TILE_ELEMENT_TYPE_TRACK)
+        if (it.element->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_ride_index(it.element) != ride_index)
@@ -1629,7 +1629,7 @@ rct_window *window_ride_open_track(rct_tile_element *tileElement)
 {
     sint32 rideIndex = track_element_get_ride_index(tileElement);
     if (
-        (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) ||
+        (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE) ||
         (TrackSequenceProperties[track_element_get_type(tileElement)][0] & TRACK_SEQUENCE_FLAG_ORIGIN)
     ) {
         // Open ride window in station view
diff --git a/src/openrct2-ui/windows/Sign.cpp b/src/openrct2-ui/windows/Sign.cpp
index 881be06992..a423ebd77a 100644
--- a/src/openrct2-ui/windows/Sign.cpp
+++ b/src/openrct2-ui/windows/Sign.cpp
@@ -168,7 +168,7 @@ rct_window * window_sign_open(rct_windownumber number)
 
     while (1)
     {
-        if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
+        if (tile_element->GetType() == TILE_ELEMENT_TYPE_LARGE_SCENERY)
         {
             rct_scenery_entry* scenery_entry = get_large_scenery_entry(scenery_large_get_type(tile_element));
             if (scenery_entry->large_scenery.scrolling_mode != 0xFF)
@@ -235,7 +235,7 @@ static void window_sign_mouseup(rct_window *w, rct_widgetindex widgetIndex)
     case WIDX_SIGN_DEMOLISH:
         while (1)
         {
-            if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
+            if (tile_element->GetType() == TILE_ELEMENT_TYPE_LARGE_SCENERY)
             {
                 rct_scenery_entry* scenery_entry = get_large_scenery_entry(scenery_large_get_type(tile_element));
                 if (scenery_entry->large_scenery.scrolling_mode != 0xFF)
@@ -437,7 +437,7 @@ rct_window * window_sign_small_open(rct_windownumber number){
     rct_tile_element* tile_element = map_get_first_element_at(view_x / 32, view_y / 32);
 
     while (1){
-        if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_WALL) {
+        if (tile_element->GetType() == TILE_ELEMENT_TYPE_WALL) {
             rct_scenery_entry* scenery_entry = get_wall_entry(tile_element->properties.wall.type);
             if (scenery_entry->wall.scrolling_mode != 0xFF){
                 if (tile_element->properties.wall.banner_index == w->number)
@@ -500,7 +500,7 @@ static void window_sign_small_mouseup(rct_window *w, rct_widgetindex widgetIndex
         break;
     case WIDX_SIGN_DEMOLISH:
         while (1){
-            if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_WALL) {
+            if (tile_element->GetType() == TILE_ELEMENT_TYPE_WALL) {
                 rct_scenery_entry* scenery_entry = get_wall_entry(tile_element->properties.wall.type);
                 if (scenery_entry->wall.scrolling_mode != 0xFF){
                     if (tile_element->properties.wall.banner_index == w->number)
diff --git a/src/openrct2-ui/windows/TileInspector.cpp b/src/openrct2-ui/windows/TileInspector.cpp
index 37049cf8fb..a100e8a8cc 100644
--- a/src/openrct2-ui/windows/TileInspector.cpp
+++ b/src/openrct2-ui/windows/TileInspector.cpp
@@ -605,7 +605,7 @@ static void window_tile_inspector_select_element_from_list(rct_window *w, sint32
 
         // Get type of selected map element to select the correct page
         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;
+        page = (Math::Min<uint32>(tileElement->GetType(), TILE_ELEMENT_TYPE_CORRUPT) >> 2) + 1;
     }
 
     window_tile_inspector_set_page(w, (TILE_INSPECTOR_PAGE)page);
@@ -1264,7 +1264,7 @@ static void window_tile_inspector_dropdown(rct_window *w, rct_widgetindex widget
 
     switch (w->page) {
     case TILE_INSPECTOR_PAGE_WALL:
-        openrct2_assert(tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL, "Element is not a wall");
+        openrct2_assert(tileElement->GetType() == TILE_ELEMENT_TYPE_WALL, "Element is not a wall");
 
         switch (widgetIndex) {
         case WIDX_WALL_DROPDOWN_SLOPE_BUTTON:
@@ -2005,7 +2005,7 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
 
     gCurrentFontSpriteBase = FONT_SPRITE_BASE_MEDIUM;
     do {
-        sint32 type = tile_element_get_type(tileElement);
+        sint32 type = tileElement->GetType();
         const char * typeName = "";
         sint32 baseHeight = tileElement->base_height;
         sint32 clearanceHeight = tileElement->clearance_height;
diff --git a/src/openrct2/Cheats.cpp b/src/openrct2/Cheats.cpp
index 0f7b94afc8..9fc80b8706 100644
--- a/src/openrct2/Cheats.cpp
+++ b/src/openrct2/Cheats.cpp
@@ -89,7 +89,7 @@ static void cheat_water_plants()
 
     tile_element_iterator_begin(&it);
     do {
-        if (tile_element_get_type(it.element) == TILE_ELEMENT_TYPE_SMALL_SCENERY) {
+        if (it.element->GetType() == TILE_ELEMENT_TYPE_SMALL_SCENERY) {
             it.element->properties.scenery.age = 0;
         }
     } while (tile_element_iterator_next(&it));
@@ -103,7 +103,7 @@ static void cheat_fix_vandalism()
 
     tile_element_iterator_begin(&it);
     do {
-        if (tile_element_get_type(it.element) != TILE_ELEMENT_TYPE_PATH)
+        if (it.element->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         if (!footpath_element_has_path_scenery(it.element))
@@ -131,7 +131,7 @@ static void cheat_remove_litter()
 
     tile_element_iterator_begin(&it);
     do {
-        if (tile_element_get_type(it.element) != TILE_ELEMENT_TYPE_PATH)
+        if (it.element->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         if (!footpath_element_has_path_scenery(it.element))
diff --git a/src/openrct2/EditorObjectSelectionSession.cpp b/src/openrct2/EditorObjectSelectionSession.cpp
index 1c02c5a8c5..1567440f53 100644
--- a/src/openrct2/EditorObjectSelectionSession.cpp
+++ b/src/openrct2/EditorObjectSelectionSession.cpp
@@ -129,7 +129,7 @@ void setup_in_use_selection_flags()
         uint16 type;
         rct_banner* banner;
 
-        switch (tile_element_get_type(iter.element)) {
+        switch (iter.element->GetType()) {
         default:
         case TILE_ELEMENT_TYPE_SURFACE:
         case TILE_ELEMENT_TYPE_TRACK:
diff --git a/src/openrct2/actions/RideDemolishAction.hpp b/src/openrct2/actions/RideDemolishAction.hpp
index 11d52aca94..f591d51f10 100644
--- a/src/openrct2/actions/RideDemolishAction.hpp
+++ b/src/openrct2/actions/RideDemolishAction.hpp
@@ -254,7 +254,7 @@ private:
         tile_element_iterator_begin(&it);
         while (tile_element_iterator_next(&it))
         {
-            if (tile_element_get_type(it.element) != TILE_ELEMENT_TYPE_TRACK)
+            if (it.element->GetType() != TILE_ELEMENT_TYPE_TRACK)
                 continue;
 
             if (track_element_get_ride_index(it.element) != _rideIndex)
diff --git a/src/openrct2/interface/Console.cpp b/src/openrct2/interface/Console.cpp
index abc42308e2..29f4c18075 100644
--- a/src/openrct2/interface/Console.cpp
+++ b/src/openrct2/interface/Console.cpp
@@ -907,7 +907,7 @@ cc_remove_park_fences(InteractiveConsole & console, [[maybe_unused]] const utf8
     tile_element_iterator_begin(&it);
     do
     {
-        if (tile_element_get_type(it.element) == TILE_ELEMENT_TYPE_SURFACE)
+        if (it.element->GetType() == TILE_ELEMENT_TYPE_SURFACE)
         {
             // Remove all park fence flags
             it.element->properties.surface.ownership &= 0xF0;
diff --git a/src/openrct2/interface/ViewportInteraction.cpp b/src/openrct2/interface/ViewportInteraction.cpp
index 56c0fea8f2..5538d1bd35 100644
--- a/src/openrct2/interface/ViewportInteraction.cpp
+++ b/src/openrct2/interface/ViewportInteraction.cpp
@@ -218,7 +218,7 @@ 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(tileElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)
             return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
 
         ride = get_ride(tile_element_get_ride_index(tileElement));
@@ -227,7 +227,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
 
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY);
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE) {
             rct_string_id stringId;
             if (tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_ENTRANCE) {
                 if (ride->num_stations > 1) {
@@ -335,7 +335,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(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
             break;
 
         set_map_tooltip_format_arg(0, rct_string_id, STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE);
@@ -450,7 +450,7 @@ static void viewport_interaction_remove_footpath(rct_tile_element *tileElement,
 
     tileElement2 = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(tileElement2) == TILE_ELEMENT_TYPE_PATH && tileElement2->base_height == z) {
+        if (tileElement2->GetType() == TILE_ELEMENT_TYPE_PATH && tileElement2->base_height == z) {
             gGameCommandErrorTitle = STR_CANT_REMOVE_FOOTPATH_FROM_HERE;
             footpath_remove(x, y, z, GAME_COMMAND_FLAG_APPLY);
             break;
diff --git a/src/openrct2/paint/VirtualFloor.cpp b/src/openrct2/paint/VirtualFloor.cpp
index b20dbd0c56..edaf06619d 100644
--- a/src/openrct2/paint/VirtualFloor.cpp
+++ b/src/openrct2/paint/VirtualFloor.cpp
@@ -252,7 +252,7 @@ static void virtual_floor_get_tile_properties(sint16 x, sint16 y, sint16 height,
     rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        sint32 elementType = tile_element_get_type(tileElement);
+        sint32 elementType = tileElement->GetType();
 
         if (elementType == TILE_ELEMENT_TYPE_SURFACE)
         {
diff --git a/src/openrct2/paint/tile_element/TileElement.cpp b/src/openrct2/paint/tile_element/TileElement.cpp
index 1e0b6c4e2c..0bc3ecee19 100644
--- a/src/openrct2/paint/tile_element/TileElement.cpp
+++ b/src/openrct2/paint/tile_element/TileElement.cpp
@@ -218,7 +218,7 @@ static void sub_68B3FB(paint_session * session, sint32 x, sint32 y)
 
     element--;
 
-    if (tile_element_get_type(element) == TILE_ELEMENT_TYPE_SURFACE &&
+    if (element->GetType() == TILE_ELEMENT_TYPE_SURFACE &&
         (surface_get_water_height(element) > 0))
     {
         max_height = surface_get_water_height(element) * 2;
@@ -267,7 +267,7 @@ static void sub_68B3FB(paint_session * session, sint32 x, sint32 y)
                 {
                     break;
                 }
-                switch (tile_element_get_type(tile_element_sub_iterator))
+                switch (tile_element_sub_iterator->GetType())
                 {
                 case TILE_ELEMENT_TYPE_PATH:
                     session->PathElementOnSameHeight = tile_element_sub_iterator;
@@ -291,7 +291,7 @@ static void sub_68B3FB(paint_session * session, sint32 x, sint32 y)
         LocationXY16 dword_9DE574 = session->MapPosition;
         session->CurrentlyDrawnItem = tile_element;
         // Setup the painting of for example: the underground, signs, rides, scenery, etc.
-        switch (tile_element_get_type(tile_element))
+        switch (tile_element->GetType())
         {
         case TILE_ELEMENT_TYPE_SURFACE:
             surface_paint(session, direction, height, tile_element);
@@ -341,7 +341,7 @@ static void sub_68B3FB(paint_session * session, sint32 x, sint32 y)
         return;
     }
 
-    if (tile_element_get_type(tile_element - 1) == TILE_ELEMENT_TYPE_SURFACE) {
+    if ((tile_element - 1)->GetType() == TILE_ELEMENT_TYPE_SURFACE) {
         return;
     }
 
diff --git a/src/openrct2/peep/Peep.cpp b/src/openrct2/peep/Peep.cpp
index c2830c7823..90dc78ef9a 100644
--- a/src/openrct2/peep/Peep.cpp
+++ b/src/openrct2/peep/Peep.cpp
@@ -617,7 +617,7 @@ static uint8 peep_assess_surroundings(sint16 centre_x, sint16 centre_y, sint16 c
                 Ride *              ride;
                 rct_scenery_entry * scenery;
 
-                switch (tile_element_get_type(tileElement))
+                switch (tileElement->GetType())
                 {
                 case TILE_ELEMENT_TYPE_PATH:
                     if (!footpath_element_has_path_scenery(tileElement))
@@ -1242,7 +1242,7 @@ static void peep_128_tick_update(rct_peep * peep, sint32 index)
                 bool               found       = false;
                 do
                 {
-                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+                    if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
                         continue;
                     if (tileElement->base_height != peep->next_z)
                         continue;
@@ -1495,7 +1495,7 @@ static bool checkForPath(rct_peep * peep)
 
     do
     {
-        if (tile_element_get_type(tile_element) == map_type)
+        if (tile_element->GetType() == map_type)
         {
             if (z == tile_element->base_height)
             {
@@ -2308,7 +2308,7 @@ static void peep_update_falling(rct_peep * peep)
         do
         {
             // If a path check if we are on it
-            if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH)
+            if (tile_element->GetType() == TILE_ELEMENT_TYPE_PATH)
             {
                 sint32 height = map_height_from_slope(peep->x, peep->y, tile_element->properties.surface.slope) +
                                 tile_element->base_height * 8;
@@ -2320,7 +2320,7 @@ static void peep_update_falling(rct_peep * peep)
                 saved_map    = tile_element;
                 break;
             } // If a surface get the height and see if we are on it
-            else if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_SURFACE)
+            else if (tile_element->GetType() == TILE_ELEMENT_TYPE_SURFACE)
             {
                 // If the surface is water check to see if we could be drowning
                 if (surface_get_water_height(tile_element) > 0)
@@ -2382,7 +2382,7 @@ static void peep_update_falling(rct_peep * peep)
     peep->next_z = saved_map->base_height;
 
     sint32 edx = saved_map->properties.path.type & 0x7;
-    if (tile_element_get_type(saved_map) != TILE_ELEMENT_TYPE_PATH)
+    if (saved_map->GetType() != TILE_ELEMENT_TYPE_PATH)
     {
         edx = 8;
     }
@@ -3502,7 +3502,7 @@ static void peep_update_ride_leave_vehicle(rct_peep * peep)
                 rct_tile_element * inner_map = map_get_first_element_at(vehicle->track_x / 32, vehicle->track_y / 32);
                 for (;; inner_map++)
                 {
-                    if (tile_element_get_type(inner_map) != TILE_ELEMENT_TYPE_TRACK)
+                    if (inner_map->GetType() != TILE_ELEMENT_TYPE_TRACK)
                         continue;
                     if (inner_map->base_height == vehicle->track_z / 8)
                         break;
@@ -4230,7 +4230,7 @@ static void peep_update_ride_maze_pathfinding(rct_peep * peep)
     rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK && z == tileElement->base_height)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK && z == tileElement->base_height)
             break;
 
     } while (!tile_element_is_last_for_tile(tileElement++));
@@ -4289,13 +4289,13 @@ static void peep_update_ride_maze_pathfinding(rct_peep * peep)
         if (z != tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             type = 1;
             break;
         }
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE &&
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE &&
             tileElement->properties.entrance.type == ENTRANCE_TYPE_RIDE_EXIT)
         {
             type = 2;
@@ -4389,7 +4389,7 @@ static void peep_update_ride_leave_exit(rct_peep * peep)
     rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         sint16 z = map_height_from_slope(peep->x, peep->y, tileElement->properties.path.type);
@@ -5583,7 +5583,7 @@ static void peep_update_mowing(rct_peep * peep)
 
         rct_tile_element * tile_element = map_get_first_element_at(peep->next_x / 32, peep->next_y / 32);
 
-        for (; (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SURFACE); tile_element++)
+        for (; (tile_element->GetType() != TILE_ELEMENT_TYPE_SURFACE); tile_element++)
             ;
 
         if ((tile_element->properties.surface.terrain & TILE_ELEMENT_SURFACE_TERRAIN_MASK) == (TERRAIN_GRASS << 5))
@@ -5638,7 +5638,7 @@ static void peep_update_watering(rct_peep * peep)
 
         do
         {
-            if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+            if (tile_element->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
                 continue;
 
             if (abs(((sint32)peep->next_z) - tile_element->base_height) > 4)
@@ -5704,7 +5704,7 @@ static void peep_update_emptying_bin(rct_peep * peep)
 
         for (;; tile_element++)
         {
-            if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH)
+            if (tile_element->GetType() == TILE_ELEMENT_TYPE_PATH)
             {
                 if (peep->next_z == tile_element->base_height)
                     break;
@@ -6010,7 +6010,7 @@ static sint32 peep_update_walking_find_bench(rct_peep * peep)
 
     for (;; tile_element++)
     {
-        if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element->GetType() == TILE_ELEMENT_TYPE_PATH)
         {
             if (peep->next_z == tile_element->base_height)
                 break;
@@ -6115,7 +6115,7 @@ static sint32 peep_update_walking_find_bin(rct_peep * peep)
 
     for (;; tile_element++)
     {
-        if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element->GetType() == TILE_ELEMENT_TYPE_PATH)
         {
             if (peep->next_z == tile_element->base_height)
                 break;
@@ -6220,7 +6220,7 @@ static void peep_update_walking_break_scenery(rct_peep * peep)
 
     for (;; tile_element++)
     {
-        if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element->GetType() == TILE_ELEMENT_TYPE_PATH)
         {
             if (peep->next_z == tile_element->base_height)
                 break;
@@ -6492,7 +6492,7 @@ static void peep_update_using_bin(rct_peep * peep)
 
         for (;; tile_element++)
         {
-            if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_PATH)
+            if (tile_element->GetType() != TILE_ELEMENT_TYPE_PATH)
             {
                 continue;
             }
@@ -6897,7 +6897,7 @@ static sint32 peep_update_patrolling_find_watering(rct_peep * peep)
 
         do
         {
-            if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+            if (tile_element->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
             {
                 continue;
             }
@@ -6964,7 +6964,7 @@ static sint32 peep_update_patrolling_find_bin(rct_peep * peep)
     for (;; tile_element++)
     {
 
-        if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH && (tile_element->base_height == peep->next_z))
+        if (tile_element->GetType() == TILE_ELEMENT_TYPE_PATH && (tile_element->base_height == peep->next_z))
             break;
 
         if (tile_element_is_last_for_tile(tile_element))
@@ -7356,7 +7356,7 @@ static void peep_update_walking(rct_peep * peep)
 
     for (;; tile_element++)
     {
-        if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH)
+        if (tile_element->GetType() == TILE_ELEMENT_TYPE_PATH)
         {
             if (peep->next_z == tile_element->base_height)
                 break;
@@ -9068,7 +9068,7 @@ static sint32 peep_interact_with_entrance(rct_peep * peep, sint16 x, sint16 y, r
         rct_tile_element * nextTileElement = map_get_first_element_at(next_x / 32, next_y / 32);
         do
         {
-            if (tile_element_get_type(nextTileElement) != TILE_ELEMENT_TYPE_PATH)
+            if (nextTileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
                 continue;
 
             if (footpath_element_is_queue(nextTileElement))
@@ -9636,10 +9636,10 @@ static rct_tile_element * get_banner_on_path(rct_tile_element * path_element)
     do
     {
         // Path on top, so no banners
-        if (tile_element_get_type(bannerElement) == TILE_ELEMENT_TYPE_PATH)
+        if (bannerElement->GetType() == TILE_ELEMENT_TYPE_PATH)
             return nullptr;
         // Found a banner
-        if (tile_element_get_type(bannerElement) == TILE_ELEMENT_TYPE_BANNER)
+        if (bannerElement->GetType() == TILE_ELEMENT_TYPE_BANNER)
             return bannerElement;
         // Last element so there cant be any other banners
         if (tile_element_is_last_for_tile(bannerElement))
@@ -9733,7 +9733,7 @@ static uint8 footpath_element_next_in_direction(sint16 x, sint16 y, sint16 z, rc
     {
         if (nextTileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
-        if (tile_element_get_type(nextTileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (nextTileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
         if (!is_valid_path_z_and_direction(nextTileElement, z, chosenDirection))
             continue;
@@ -9788,7 +9788,7 @@ static uint8 footpath_element_dest_in_dir(sint16 x, sint16 y, sint16 z, rct_tile
         if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
 
-        switch (tile_element_get_type(tileElement))
+        switch (tileElement->GetType())
         {
         case TILE_ELEMENT_TYPE_TRACK:
         {
@@ -10140,7 +10140,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
             continue;
 
         uint8 rideIndex = 0xFF;
-        switch (tile_element_get_type(tileElement))
+        switch (tileElement->GetType())
         {
         case TILE_ELEMENT_TYPE_TRACK:
         {
@@ -10707,7 +10707,7 @@ sint32 peep_pathfind_choose_direction(sint16 x, sint16 y, uint8 z, rct_peep * pe
     {
         if (dest_tile_element->base_height != z)
             continue;
-        if (tile_element_get_type(dest_tile_element) != TILE_ELEMENT_TYPE_PATH)
+        if (dest_tile_element->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
         found = true;
         if (first_tile_element == nullptr)
@@ -11230,7 +11230,7 @@ static void get_ride_queue_end(sint16 * x, sint16 * y, sint16 * z)
     bool found = false;
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
 
         if (*z != tileElement->base_height)
@@ -11252,7 +11252,7 @@ static void get_ride_queue_end(sint16 * x, sint16 * y, sint16 * z)
     sint16 nextY = *y;
     while (true)
     {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)
         {
             lastPathElement = tileElement;
             result.x        = nextX;
@@ -11276,7 +11276,7 @@ static void get_ride_queue_end(sint16 * x, sint16 * y, sint16 * z)
             if (tileElement == firstPathElement)
                 continue;
 
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
                 continue;
 
             if (baseZ == tileElement->base_height)
@@ -11744,17 +11744,17 @@ static sint32 peep_perform_next_action(rct_peep * peep)
         if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)
         {
             if (peep_interact_with_path(peep, x, y, tileElement))
                 return 1;
         }
-        else if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+        else if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             if (peep_interact_with_shop(peep, x, y, tileElement))
                 return 1;
         }
-        else if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE)
+        else if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE)
         {
             if (peep_interact_with_entrance(peep, x, y, tileElement))
                 return 1;
@@ -12777,7 +12777,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
         if (tile_element_get_direction(tileElement) != edge)
             continue;
@@ -12811,7 +12811,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
         if (tile_element_get_direction_with_offset(tileElement, 2) != edge)
             continue;
@@ -12844,7 +12844,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
         if (peep->next_z + 6 < tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             if (peep_should_watch_ride(tileElement))
             {
@@ -12852,7 +12852,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             }
         }
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_LARGE_SCENERY)
         {
             if (!(get_large_scenery_entry(scenery_large_get_type(tileElement))->large_scenery.flags &
                   LARGE_SCENERY_FLAG_PHOTOGENIC))
@@ -12887,12 +12887,12 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             continue;
         if (peep->next_z + 6 < tileElement->base_height)
             continue;
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_SURFACE)
             continue;
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_WALL)
         {
             auto wallEntry = get_wall_entry(tileElement->properties.wall.type);
             if (wallEntry == nullptr || (wallEntry->wall.flags2 & WALL_SCENERY_2_IS_OPAQUE))
@@ -12924,7 +12924,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
         if (tile_element_get_direction_with_offset(tileElement, 2) != edge)
             continue;
@@ -12955,7 +12955,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
         if (peep->next_z + 8 < tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             if (peep_should_watch_ride(tileElement))
             {
@@ -12963,7 +12963,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             }
         }
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_LARGE_SCENERY)
         {
             auto sceneryEntry = get_large_scenery_entry(scenery_large_get_type(tileElement));
             if (!(sceneryEntry == nullptr || sceneryEntry->large_scenery.flags &
@@ -12999,12 +12999,12 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             continue;
         if (peep->next_z + 8 < tileElement->base_height)
             continue;
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_SURFACE)
             continue;
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)
             continue;
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_WALL)
         {
             auto wallEntry = get_wall_entry(tileElement->properties.wall.type);
             if (wallEntry == nullptr || (wallEntry->wall.flags2 & WALL_SCENERY_2_IS_OPAQUE))
@@ -13036,7 +13036,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             if (tile_element_is_ghost(tileElement))
                 continue;
         }
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
         if (tile_element_get_direction_with_offset(tileElement, 2) != edge)
             continue;
@@ -13067,7 +13067,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
         if (peep->next_z + 10 < tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             if (peep_should_watch_ride(tileElement))
             {
@@ -13075,7 +13075,7 @@ static bool peep_find_ride_to_look_at(rct_peep * peep, uint8 edge, uint8 * rideT
             }
         }
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_LARGE_SCENERY)
         {
             if (!(get_large_scenery_entry(scenery_large_get_type(tileElement))->large_scenery.flags &
                   LARGE_SCENERY_FLAG_PHOTOGENIC))
@@ -13649,7 +13649,7 @@ static void peep_pick_ride_to_go_on(rct_peep * peep)
                     rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
                     do
                     {
-                        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+                        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                             continue;
 
                         sint32 rideIndex = track_element_get_ride_index(tileElement);
@@ -13788,7 +13788,7 @@ static void peep_head_for_nearest_ride_type(rct_peep * peep, sint32 rideType)
                     rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
                     do
                     {
-                        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+                        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                             continue;
 
                         sint32 rideIndex = track_element_get_ride_index(tileElement);
@@ -13920,7 +13920,7 @@ static void peep_head_for_nearest_ride_with_flags(rct_peep * peep, sint32 rideTy
                     rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
                     do
                     {
-                        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+                        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                             continue;
 
                         sint32 rideIndex = track_element_get_ride_index(tileElement);
diff --git a/src/openrct2/peep/Staff.cpp b/src/openrct2/peep/Staff.cpp
index e243c75200..ab6bda2310 100644
--- a/src/openrct2/peep/Staff.cpp
+++ b/src/openrct2/peep/Staff.cpp
@@ -706,7 +706,7 @@ bool staff_can_ignore_wide_flag(rct_peep * staff, sint32 x, sint32 y, uint8 z, r
         bool              widefound    = false;
         do
         {
-            if (tile_element_get_type(test_element) != TILE_ELEMENT_TYPE_PATH)
+            if (test_element->GetType() != TILE_ELEMENT_TYPE_PATH)
             {
                 continue;
             }
@@ -912,8 +912,8 @@ static uint8 staff_handyman_direction_to_nearest_litter(rct_peep * peep)
     {
         if (tileElement->base_height != nextZ)
             continue;
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
-            tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE ||
+            tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             return 0xFF;
         }
@@ -928,8 +928,8 @@ static uint8 staff_handyman_direction_to_nearest_litter(rct_peep * peep)
     {
         if (tileElement->base_height != nextZ)
             continue;
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE ||
-            tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE ||
+            tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             return 0xFF;
         }
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index 8339876fa3..41e4208d59 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -486,7 +486,7 @@ private:
 
         while (tileIndex < maxTiles)
         {
-            switch (tile_element_get_type(tileElement)) {
+            switch (tileElement->GetType()) {
             case TILE_ELEMENT_TYPE_PATH:
             {
                 uint8 pathType = GetPathType(tileElement);
@@ -2430,7 +2430,7 @@ private:
             if (tileElement->base_height != 255)
             {
                 // This skips walls, which are fixed later.
-                switch (tile_element_get_type(tileElement))
+                switch (tileElement->GetType())
                 {
                 case TILE_ELEMENT_TYPE_SMALL_SCENERY:
                     colour = RCT1::GetColour(scenery_small_get_primary_colour(tileElement));
@@ -2485,7 +2485,7 @@ private:
         rct_tile_element * tileElement = gTileElements;
         while (tileElement < gNextFreeTileElement)
         {
-            switch (tile_element_get_type(tileElement)) {
+            switch (tileElement->GetType()) {
             case TILE_ELEMENT_TYPE_PATH:
             {
                 // Type
@@ -2548,7 +2548,7 @@ private:
                 rct_tile_element * tileElement = map_get_first_element_at(x, y);
                 do
                 {
-                    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
+                    if (tileElement->GetType() == TILE_ELEMENT_TYPE_WALL)
                     {
                         rct_tile_element originalTileElement = *tileElement;
                         tile_element_remove(tileElement);
@@ -2629,7 +2629,7 @@ private:
                 rct_tile_element * tileElement = map_get_first_element_at(x, y);
                 do
                 {
-                    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_BANNER)
+                    if (tileElement->GetType() == TILE_ELEMENT_TYPE_BANNER)
                     {
                         uint8 index = tileElement->properties.banner.index;
                         rct_banner * src = &_s4.banners[index];
@@ -2669,7 +2669,7 @@ private:
         while (tile_element_iterator_next(&it))
         {
             rct_tile_element * element = it.element;
-            if (tile_element_get_type(element) == TILE_ELEMENT_TYPE_SURFACE)
+            if (element->GetType() == TILE_ELEMENT_TYPE_SURFACE)
             {
                 surface_set_terrain(element, RCT1::GetTerrain(surface_get_terrain(element)));
                 surface_set_terrain_edge(element, RCT1::GetTerrainEdge(surface_get_terrain_edge(element)));
@@ -2692,7 +2692,7 @@ private:
         {
             rct_tile_element * element = it.element;
 
-            if (tile_element_get_type(element) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+            if (element->GetType() != TILE_ELEMENT_TYPE_ENTRANCE) continue;
             if (element->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE) continue;
             if ((element->properties.entrance.index & 0x0F) != 0) continue;
 
@@ -2711,7 +2711,7 @@ private:
         while (tile_element_iterator_next(&it))
         {
             rct_tile_element * tileElement = it.element;
-            switch (tile_element_get_type(tileElement)) {
+            switch (tileElement->GetType()) {
             case TILE_ELEMENT_TYPE_SMALL_SCENERY:
                 tileElement->properties.scenery.type = _smallSceneryTypeToEntryMap[tileElement->properties.scenery.type];
                 break;
@@ -2804,7 +2804,7 @@ private:
                 rct_tile_element * tileElement = map_get_first_element_at(x, y);
                 do
                 {
-                    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+                    if (tileElement->GetType() == 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(tileElement))
diff --git a/src/openrct2/ride/Ride.cpp b/src/openrct2/ride/Ride.cpp
index 2c2af43c05..09e2bcd5cc 100644
--- a/src/openrct2/ride/Ride.cpp
+++ b/src/openrct2/ride/Ride.cpp
@@ -497,7 +497,7 @@ bool ride_try_get_origin_element(sint32 rideIndex, CoordsXYE *output)
     tile_element_iterator it;
     tile_element_iterator_begin(&it);
     do {
-        if (tile_element_get_type(it.element) != TILE_ELEMENT_TYPE_TRACK)
+        if (it.element->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
         if (rideIndex != track_element_get_ride_index(it.element))
             continue;
@@ -555,7 +555,7 @@ bool track_block_get_next_from_zero(sint16 x, sint16 y, sint16 z_start, uint8 ri
     }
 
     do{
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_ride_index(tileElement) != rideIndex)
@@ -679,7 +679,7 @@ bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 ride
     }
 
     do{
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_ride_index(tileElement) != rideIndex)
@@ -814,7 +814,7 @@ sint32 ride_find_track_gap(CoordsXYE *input, CoordsXYE *output)
     track_circuit_iterator it = { 0 }, slowIt;
     sint32 rideIndex;
 
-    assert(tile_element_get_type(input->element) == TILE_ELEMENT_TYPE_TRACK);
+    assert(input->element->GetType() == TILE_ELEMENT_TYPE_TRACK);
     rideIndex = track_element_get_ride_index(input->element);
     ride = get_ride(rideIndex);
 
@@ -1222,7 +1222,7 @@ sint32 sub_6C683D(sint32* x, sint32* y, sint32* z, sint32 direction, sint32 type
         if (tileElement->base_height != *z / 8)
             continue;
 
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if ((tile_element_get_direction(tileElement)) != direction)
@@ -1298,7 +1298,7 @@ sint32 sub_6C683D(sint32* x, sint32* y, sint32* z, sint32 direction, sint32 type
             if (tileElement->base_height != cur_z / 8)
                 continue;
 
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                 continue;
 
             if ((tile_element_get_direction(tileElement)) != direction)
@@ -1871,7 +1871,7 @@ sint32 ride_modify(CoordsXYE *input)
     ride_set_status(rideIndex, RIDE_STATUS_CLOSED);
 
     // Check if element is a station entrance or exit
-    if (tile_element_get_type(tileElement.element) == TILE_ELEMENT_TYPE_ENTRANCE)
+    if (tileElement.element->GetType() == TILE_ELEMENT_TYPE_ENTRANCE)
         return ride_modify_entrance_or_exit(tileElement.element, tileElement.x, tileElement.y);
 
     ride_create_or_find_construction_window(rideIndex);
@@ -3274,7 +3274,7 @@ static void ride_shop_connected(Ride* ride, sint32 ride_idx)
 
     tileElement = map_get_first_element_at(x, y);
     do {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK && track_element_get_ride_index(tileElement) == ride_idx)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK && track_element_get_ride_index(tileElement) == ride_idx)
             break;
     } while (!tile_element_is_last_for_tile(tileElement++));
 
@@ -3429,7 +3429,7 @@ static void ride_entrance_set_map_tooltip(rct_tile_element *tileElement)
 
 void ride_set_map_tooltip(rct_tile_element *tileElement)
 {
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE)
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE)
     {
         ride_entrance_set_map_tooltip(tileElement);
     }
@@ -4123,7 +4123,7 @@ static void sub_6B5952(sint32 rideIndex)
         // the ride or not.
         rct_tile_element * tileElement = map_get_first_element_at(location.x, location.y);
         do {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
             if (tileElement->base_height != z)
                 continue;
@@ -4430,7 +4430,7 @@ static void ride_set_maze_entrance_exit_points(Ride *ride)
 
         rct_tile_element *tileElement = map_get_first_element_at((*position).x, (*position).y);
         do {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE) continue;
             if (
                 tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE &&
                 tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_EXIT
@@ -4815,7 +4815,7 @@ static void ride_create_vehicles_find_first_block(Ride *ride, CoordsXYE *outXYEl
             if (track_element_is_lift_hill(trackElement)) {
                 rct_tile_element *tileElement = map_get_first_element_at(trackBeginEnd.begin_x >> 5, trackBeginEnd.begin_y >> 5);
                 do {
-                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+                    if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
                     if (track_element_get_type(tileElement) != trackType) continue;
                     if (tile_element_get_track_sequence(tileElement) != 0) continue;
                     if (tileElement->base_height != trackBeginEnd.begin_z / 8) continue;
@@ -4877,7 +4877,7 @@ static bool ride_create_vehicles(Ride *ride, sint32 rideIndex, CoordsXYE *elemen
         tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do {
             if (tileElement->base_height != z) continue;
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
             break;
         } while (!tile_element_is_last_for_tile(tileElement++));
 
@@ -4997,7 +4997,7 @@ static bool ride_initialise_cable_lift_track(Ride *ride, bool isApplying)
     bool success = false;
     rct_tile_element *tileElement = map_get_first_element_at(location.x, location.y);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
         if (tileElement->base_height != z) continue;
 
         if (!(TrackSequenceProperties[track_element_get_type(tileElement)][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) {
@@ -5104,7 +5104,7 @@ static bool ride_create_cable_lift(sint32 rideIndex, bool isApplying)
     sint32 z = ride->cable_lift_z;
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
         if (tileElement->base_height != z) continue;
         break;
     } while (!tile_element_is_last_for_tile(tileElement++));
@@ -5219,7 +5219,7 @@ static rct_tile_element *loc_6B4F6B(sint32 rideIndex, sint32 x, sint32 y)
     Ride * ride = get_ride(rideIndex);
     rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (RideProperties[ride->type].flags & RIDE_TYPE_FLAG_FLAT_RIDE) {
@@ -5508,7 +5508,7 @@ sint32 ride_get_refund_price(sint32 ride_id)
 
     tile_element_iterator_begin(&it);
     while (tile_element_iterator_next(&it)) {
-        if (tile_element_get_type(it.element) != TILE_ELEMENT_TYPE_TRACK)
+        if (it.element->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_ride_index(it.element) != ride_id)
@@ -6490,7 +6490,7 @@ bool ride_has_any_track_elements(sint32 rideIndex)
 
     tile_element_iterator_begin(&it);
     while (tile_element_iterator_next(&it)) {
-        if (tile_element_get_type(it.element) != TILE_ELEMENT_TYPE_TRACK)
+        if (it.element->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
         if (track_element_get_ride_index(it.element) != rideIndex)
             continue;
@@ -6511,7 +6511,7 @@ void ride_all_has_any_track_elements(bool *rideIndexArray)
 
     tile_element_iterator_begin(&it);
     while (tile_element_iterator_next(&it)) {
-        if (tile_element_get_type(it.element) != TILE_ELEMENT_TYPE_TRACK)
+        if (it.element->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
         if (it.element->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
@@ -6652,7 +6652,7 @@ void ride_get_entrance_or_exit_position_from_screen_position(sint32 screenX, sin
     get_map_coordinates_from_pos(screenX, screenY, 0xFFFB, &mapX, &mapY, &interactionType, &tileElement, &viewport);
     if (interactionType != 0)
     {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             if (track_element_get_ride_index(tileElement) == gRideEntranceExitPlaceRideIndex)
             {
@@ -6719,7 +6719,7 @@ void ride_get_entrance_or_exit_position_from_screen_position(sint32 screenX, sin
                 tileElement = map_get_first_element_at(mapX >> 5, mapY >> 5);
                 do
                 {
-                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+                    if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                         continue;
                     if (tileElement->base_height != stationHeight)
                         continue;
@@ -6775,7 +6775,7 @@ void ride_get_entrance_or_exit_position_from_screen_position(sint32 screenX, sin
 
             do
             {
-                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+                if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                     continue;
                 if (track_element_get_ride_index(tileElement) != gRideEntranceExitPlaceRideIndex)
                     continue;
@@ -7092,7 +7092,7 @@ static sint32 ride_get_track_length(Ride * ride)
         tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do
         {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                 continue;
 
             trackType = track_element_get_type(tileElement);
@@ -7530,7 +7530,7 @@ void sub_6CB945(sint32 rideIndex)
                 bool trackFound = false;
                 do {
                     if (tileElement->base_height != location.z) continue;
-                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+                    if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
                     if (track_element_get_ride_index(tileElement) != rideIndex) continue;
                     if (tile_element_get_track_sequence(tileElement) != 0) continue;
                     if (!(TrackSequenceProperties[track_element_get_type(tileElement)][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) continue;
@@ -7565,7 +7565,7 @@ void sub_6CB945(sint32 rideIndex)
                 tileElement = map_get_first_element_at(blockLocation.x >> 5, blockLocation.y >> 5);
                 do {
                     if (blockLocation.z != tileElement->base_height) continue;
-                    if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+                    if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
                     if (!(TrackSequenceProperties[track_element_get_type(tileElement)][0] & TRACK_SEQUENCE_FLAG_ORIGIN)) continue;
 
                     trackFound = true;
@@ -7626,7 +7626,7 @@ void sub_6CB945(sint32 rideIndex)
 
         rct_tile_element *tileElement = map_get_first_element_at(location.x >> 5, location.y >> 5);
         do {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE) continue;
             if (tileElement->properties.entrance.ride_index != rideIndex) continue;
             if (tileElement->properties.entrance.type > ENTRANCE_TYPE_RIDE_EXIT) continue;
 
@@ -7637,7 +7637,7 @@ void sub_6CB945(sint32 rideIndex)
             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->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
                 if (track_element_get_ride_index(trackElement) != rideIndex) continue;
                 if (trackElement->base_height != tileElement->base_height) continue;
 
@@ -7967,7 +7967,7 @@ rct_tile_element *get_station_platform(sint32 x, sint32 y, sint32 z, sint32 z_to
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     if (tileElement != nullptr) {
         do {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
             /* Check if tileElement is a station platform. */
             if (!track_element_is_station(tileElement)) continue;
 
@@ -8386,7 +8386,7 @@ void determine_ride_entrance_and_exit_locations()
                     {
                         do
                         {
-                            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+                            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
                             {
                                 continue;
                             }
diff --git a/src/openrct2/ride/RideRatings.cpp b/src/openrct2/ride/RideRatings.cpp
index 6f6532df2f..c61173b4bf 100644
--- a/src/openrct2/ride/RideRatings.cpp
+++ b/src/openrct2/ride/RideRatings.cpp
@@ -201,7 +201,7 @@ static void ride_ratings_update_state_2()
 
     rct_tile_element *tileElement = map_get_first_element_at(x, y);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
         if (tileElement->base_height != z)
             continue;
@@ -299,7 +299,7 @@ static void ride_ratings_update_state_5()
 
     rct_tile_element *tileElement = map_get_first_element_at(x, y);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
         if (tileElement->base_height != z)
             continue;
@@ -395,7 +395,7 @@ static void ride_ratings_score_close_proximity_in_direction(rct_tile_element *in
 
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        switch (tile_element_get_type(tileElement)) {
+        switch (tileElement->GetType()) {
         case TILE_ELEMENT_TYPE_SURFACE:
             if (gRideRatingsCalcData.proximity_base_height <= inputTileElement->base_height) {
                 if (inputTileElement->clearance_height <= tileElement->base_height) {
@@ -434,7 +434,7 @@ static void ride_ratings_score_close_proximity_loops_helper(rct_tile_element *in
 {
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        switch (tile_element_get_type(tileElement)) {
+        switch (tileElement->GetType()) {
         case TILE_ELEMENT_TYPE_PATH:
         {
             sint32 zDiff = (sint32)tileElement->base_height - (sint32)inputTileElement->base_height;
@@ -500,7 +500,7 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputTileElemen
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
         sint32 waterHeight;
-        switch (tile_element_get_type(tileElement)) {
+        switch (tileElement->GetType()) {
         case TILE_ELEMENT_TYPE_SURFACE:
             gRideRatingsCalcData.proximity_base_height = tileElement->base_height;
             if (tileElement->base_height * 8 == gRideRatingsCalcData.proximity_z) {
@@ -614,7 +614,7 @@ static void ride_ratings_score_close_proximity(rct_tile_element *inputTileElemen
                 }
             }
         } break;
-        } // switch tile_element_get_type
+        } // switch tileElement->GetType
     } while (!tile_element_is_last_for_tile(tileElement++));
 
     uint8 direction = tile_element_get_direction(inputTileElement);
@@ -1307,7 +1307,7 @@ static sint32 ride_ratings_get_scenery_score(Ride *ride)
                 if (tileElement->flags & (1 << 4))
                     continue;
 
-                sint32 type = tile_element_get_type(tileElement);
+                sint32 type = tileElement->GetType();
                 if (type == TILE_ELEMENT_TYPE_SMALL_SCENERY || type == TILE_ELEMENT_TYPE_LARGE_SCENERY)
                     numSceneryItems++;
             } while (!tile_element_is_last_for_tile(tileElement++));
diff --git a/src/openrct2/ride/Station.cpp b/src/openrct2/ride/Station.cpp
index 98c9054390..b6759c4d0a 100644
--- a/src/openrct2/ride/Station.cpp
+++ b/src/openrct2/ride/Station.cpp
@@ -321,7 +321,7 @@ rct_tile_element * ride_get_station_start_track_element(Ride * ride, sint32 stat
     rct_tile_element * tileElement = map_get_first_element_at(x, y);
     do
     {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK && z == tileElement->base_height)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK && z == tileElement->base_height)
             return tileElement;
 
     }
@@ -336,7 +336,7 @@ rct_tile_element * ride_get_station_exit_element(sint32 x, sint32 y, sint32 z)
     rct_tile_element * tileElement = map_get_first_element_at(x, y);
     do
     {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE && z == tileElement->base_height)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE && z == tileElement->base_height)
             return tileElement;
     }
     while (!tile_element_is_last_for_tile(tileElement++));
diff --git a/src/openrct2/ride/Track.cpp b/src/openrct2/ride/Track.cpp
index 4f09b9d52a..af84b71c68 100644
--- a/src/openrct2/ride/Track.cpp
+++ b/src/openrct2/ride/Track.cpp
@@ -614,7 +614,7 @@ static rct_tile_element * find_station_element(sint32 x, sint32 y, sint32 z, sin
     {
         if (z != tileElement->base_height)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
         if (tile_element_get_direction(tileElement) != direction)
             continue;
@@ -1658,7 +1658,7 @@ static money32 track_remove(uint8 type,
         if (tileElement->base_height * 8 != originZ)
             continue;
 
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if ((tile_element_get_direction(tileElement)) != rotation)
@@ -1771,7 +1771,7 @@ static money32 track_remove(uint8 type,
             if (tileElement->base_height != z / 8)
                 continue;
 
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                 continue;
 
             if ((tile_element_get_direction(tileElement)) != rotation)
@@ -1985,7 +1985,7 @@ void game_command_set_brakes_speed(
     {
         if (tileElement->base_height * 8 != z)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
         if (track_element_get_type(tileElement) != trackType)
             continue;
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index ba4ae33c42..53dd31be44 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -1594,7 +1594,7 @@ static bool track_design_place_ride(rct_track_td6 * td6, sint16 x, sint16 y, sin
 
                 do
                 {
-                    if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_TRACK)
+                    if (tile_element->GetType() != TILE_ELEMENT_TYPE_TRACK)
                     {
                         continue;
                     }
diff --git a/src/openrct2/ride/TrackDesignSave.cpp b/src/openrct2/ride/TrackDesignSave.cpp
index e412917a35..4411b97305 100644
--- a/src/openrct2/ride/TrackDesignSave.cpp
+++ b/src/openrct2/ride/TrackDesignSave.cpp
@@ -206,7 +206,7 @@ static sint32 tile_element_get_total_element_count(rct_tile_element *tileElement
     rct_scenery_entry *sceneryEntry;
     rct_large_scenery_tile *tile;
 
-    switch (tile_element_get_type(tileElement)) {
+    switch (tileElement->GetType()) {
     case TILE_ELEMENT_TYPE_PATH:
     case TILE_ELEMENT_TYPE_SMALL_SCENERY:
     case TILE_ELEMENT_TYPE_WALL:
@@ -563,7 +563,7 @@ static void track_design_save_remove_tile_element(sint32 interactionType, sint32
 
 static bool track_design_save_should_select_scenery_around(sint32 rideIndex, rct_tile_element *tileElement)
 {
-    switch (tile_element_get_type(tileElement)) {
+    switch (tileElement->GetType()) {
     case TILE_ELEMENT_TYPE_PATH:
         if ((tileElement->type & FOOTPATH_ELEMENT_TYPE_FLAG_IS_QUEUE) && tileElement->properties.path.addition_status == rideIndex)
             return true;
@@ -593,7 +593,7 @@ static void track_design_save_select_nearby_scenery_for_tile(sint32 rideIndex, s
             tileElement = map_get_first_element_at(x, y);
             do {
                 sint32 interactionType = VIEWPORT_INTERACTION_ITEM_NONE;
-                switch (tile_element_get_type(tileElement)) {
+                switch (tileElement->GetType()) {
                 case TILE_ELEMENT_TYPE_PATH:
                     if (!(tileElement->type & FOOTPATH_ELEMENT_TYPE_FLAG_IS_QUEUE))
                         interactionType = VIEWPORT_INTERACTION_ITEM_FOOTPATH;
@@ -798,7 +798,7 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
         for (startX = 0; startX < 8192; startX += 32) {
             tileElement = map_get_first_element_at(startX >> 5, startY >> 5);
             do {
-                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+                if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                     continue;
                 if (track_element_get_ride_index(tileElement) == rideIndex){
                     mapFound = true;
@@ -832,7 +832,7 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
         for (; x < 8192; x += 32) {
             tileElement = map_get_first_element_at(x / 32, y / 32);
             do {
-                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+                if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
                 if (track_element_get_ride_index(tileElement) != rideIndex) continue;
 
                 maze->maze_entry = track_element_get_maze_entry(tileElement);
@@ -866,7 +866,7 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
 
     tileElement = map_get_first_element_at(location.x, location.y);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+        if (tileElement->GetType() != 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++));
@@ -892,7 +892,7 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
     y = location.y * 32;
     tileElement = map_get_first_element_at(location.x, location.y);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+        if (tileElement->GetType() != 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++));
@@ -1068,7 +1068,7 @@ static bool track_design_save_to_td6_for_tracked_ride(uint8 rideIndex, rct_track
 
             rct_tile_element *tile_element = map_get_first_element_at(x >> 5, y >> 5);
             do {
-                if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_ENTRANCE) continue;
+                if (tile_element->GetType() != TILE_ELEMENT_TYPE_ENTRANCE) continue;
                 if (tile_element->base_height == z) break;
             } while (!tile_element_is_last_for_tile(tile_element++));
             // Add something that stops this from walking off the end
diff --git a/src/openrct2/ride/Vehicle.cpp b/src/openrct2/ride/Vehicle.cpp
index 47c7fb2221..204a2104a0 100644
--- a/src/openrct2/ride/Vehicle.cpp
+++ b/src/openrct2/ride/Vehicle.cpp
@@ -1836,19 +1836,19 @@ static void vehicle_update_measurements(rct_vehicle * vehicle)
         bool cover_found = false;
         do
         {
-            if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_LARGE_SCENERY)
+            if (tile_element->GetType() == TILE_ELEMENT_TYPE_LARGE_SCENERY)
             {
                 cover_found = true;
                 break;
             }
 
-            if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH)
+            if (tile_element->GetType() == TILE_ELEMENT_TYPE_PATH)
             {
                 cover_found = true;
                 break;
             }
 
-            if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+            if (tile_element->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
                 continue;
 
             rct_scenery_entry * scenery = get_small_scenery_entry(tile_element->properties.scenery.type);
@@ -4684,7 +4684,7 @@ static bool vehicle_boat_is_location_accessible(const TileCoordsXYZ &location)
     rct_tile_element * tileElement = map_get_first_element_at(location.x, location.y);
     do
     {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SURFACE)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_SURFACE)
         {
             sint32 waterZ = surface_get_water_height(tileElement) * 2;
             if (location.z != waterZ)
diff --git a/src/openrct2/ride/transport/Chairlift.cpp b/src/openrct2/ride/transport/Chairlift.cpp
index 9d2fb8c19c..3fa15f9639 100644
--- a/src/openrct2/ride/transport/Chairlift.cpp
+++ b/src/openrct2/ride/transport/Chairlift.cpp
@@ -125,7 +125,7 @@ chairlift_paint_util_map_get_track_element_at_from_ride_fuzzy(sint32 x, sint32 y
 
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
         if (track_element_get_ride_index(tileElement) != rideIndex)
             continue;
diff --git a/src/openrct2/scenario/Scenario.cpp b/src/openrct2/scenario/Scenario.cpp
index 842bad2482..542178f3e4 100644
--- a/src/openrct2/scenario/Scenario.cpp
+++ b/src/openrct2/scenario/Scenario.cpp
@@ -609,7 +609,7 @@ static bool scenario_prepare_rides_for_save()
     tile_element_iterator_begin(&it);
     do
     {
-        if (tile_element_get_type(it.element) == TILE_ELEMENT_TYPE_TRACK)
+        if (it.element->GetType() == TILE_ELEMENT_TYPE_TRACK)
         {
             markTrackAsIndestructible = false;
 
diff --git a/src/openrct2/world/Banner.cpp b/src/openrct2/world/Banner.cpp
index bdb243e387..a4e70698f2 100644
--- a/src/openrct2/world/Banner.cpp
+++ b/src/openrct2/world/Banner.cpp
@@ -54,7 +54,7 @@ static sint32 banner_get_ride_index_at(sint32 x, sint32 y, sint32 z)
     tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         rideIndex = track_element_get_ride_index(tileElement);
@@ -150,7 +150,7 @@ static money32 BannerSetColour(sint16 x, sint16 y, uint8 baseHeight, uint8 direc
         bool found = false;
         do
         {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_BANNER)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_BANNER)
                 continue;
 
             if (tileElement->properties.banner.position != direction)
@@ -203,7 +203,7 @@ static money32 BannerPlace(sint16 x, sint16 y, uint8 pathBaseHeight, uint8 direc
     bool pathFound = false;
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         if (tileElement->base_height != pathBaseHeight * 2 && tileElement->base_height != (pathBaseHeight - 1) * 2)
@@ -498,7 +498,7 @@ void fix_duplicated_banners()
             {
                 // TODO: Handle walls and large-scenery that use banner indices too. Large scenery can be tricky, as they occupy
                 // multiple tiles that should both refer to the same banner index.
-                if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_BANNER)
+                if (tileElement->GetType() == TILE_ELEMENT_TYPE_BANNER)
                 {
                     uint8 bannerIndex = tileElement->properties.banner.index;
                     if (activeBanners[bannerIndex])
diff --git a/src/openrct2/world/Entrance.cpp b/src/openrct2/world/Entrance.cpp
index 4afbf550ac..826911122c 100644
--- a/src/openrct2/world/Entrance.cpp
+++ b/src/openrct2/world/Entrance.cpp
@@ -388,7 +388,7 @@ static money32 RideEntranceExitRemove(sint16 x, sint16 y, uint8 rideIndex, uint8
 
         do
         {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
 
             if (tile_element_get_ride_index(tileElement) != rideIndex)
diff --git a/src/openrct2/world/Footpath.cpp b/src/openrct2/world/Footpath.cpp
index d6281631af..f0ded2019b 100644
--- a/src/openrct2/world/Footpath.cpp
+++ b/src/openrct2/world/Footpath.cpp
@@ -136,7 +136,7 @@ rct_tile_element *map_get_footpath_element(sint32 x, sint32 y, sint32 z)
 
     tileElement = map_get_first_element_at(x, y);
     do {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH && tileElement->base_height == z)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH && tileElement->base_height == z)
             return tileElement;
     } while (!tile_element_is_last_for_tile(tileElement++));
 
@@ -150,7 +150,7 @@ static rct_tile_element *map_get_footpath_element_slope(sint32 x, sint32 y, sint
     tileElement = map_get_first_element_at(x, y);
     do {
         if (
-            tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH &&
+            tileElement->GetType() == TILE_ELEMENT_TYPE_PATH &&
             tileElement->base_height == z &&
             (tileElement->properties.path.type & (FOOTPATH_PROPERTIES_FLAG_IS_SLOPED | FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK)) == slope
         ) {
@@ -468,8 +468,8 @@ static money32 footpath_place_real(sint32 type, sint32 x, sint32 y, sint32 z, si
  */
 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;
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)return;
+        else if (tileElement->GetType() != TILE_ELEMENT_TYPE_BANNER)continue;
 
         game_do_command(x, 1, y, tileElement->base_height | tileElement->properties.banner.position << 8, GAME_COMMAND_REMOVE_BANNER, 0, 0);
         tileElement--;
@@ -933,7 +933,7 @@ void footpath_bridge_get_info_from_pos(sint32 screenX, sint32 screenY, sint32 *x
 
     if (interactionType == VIEWPORT_INTERACTION_ITEM_RIDE
         && viewport->flags & (VIEWPORT_FLAG_UNDERGROUND_INSIDE | VIEWPORT_FLAG_HIDE_BASE | VIEWPORT_FLAG_HIDE_VERTICAL)
-        && tile_element_get_type(*tileElement) == TILE_ELEMENT_TYPE_ENTRANCE
+        && (*tileElement)->GetType() == TILE_ELEMENT_TYPE_ENTRANCE
     ) {
         sint32 directions = entrance_get_directions(*tileElement);
         if (directions & 0x0F) {
@@ -948,7 +948,7 @@ void footpath_bridge_get_info_from_pos(sint32 screenX, sint32 screenY, sint32 *x
     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(*tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+    if (interactionType == VIEWPORT_INTERACTION_ITEM_RIDE && (*tileElement)->GetType() == TILE_ELEMENT_TYPE_ENTRANCE) {
         sint32 directions = entrance_get_directions(*tileElement);
         if (directions & 0x0F) {
             sint32 bx = tile_element_get_direction_with_offset(*tileElement, bitscanforward(directions));
@@ -1021,7 +1021,7 @@ bool fence_in_the_way(sint32 x, sint32 y, sint32 z0, sint32 z1, sint32 direction
     if (tileElement == nullptr)
         return false;
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
         if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
@@ -1051,7 +1051,7 @@ static rct_tile_element *footpath_connect_corners_get_neighbour(sint32 x, sint32
 {
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
         if (footpath_element_is_queue(tileElement))
             continue;
@@ -1208,7 +1208,7 @@ static rct_tile_element *footpath_get_element(sint32 x, sint32 y, sint32 z0, sin
 
     tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         if (z1 == tileElement->base_height) {
@@ -1301,7 +1301,7 @@ static void loc_6A6D7E(
     } else {
         rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
         do {
-            switch (tile_element_get_type(tileElement)) {
+            switch (tileElement->GetType()) {
             case TILE_ELEMENT_TYPE_PATH:
                 if (z == tileElement->base_height) {
                     if (footpath_element_is_sloped(tileElement) && footpath_element_get_slope_direction(tileElement) != direction) {
@@ -1366,7 +1366,7 @@ static void loc_6A6D7E(
                 if (connected_path_count[tileElement->properties.path.edges & FOOTPATH_PROPERTIES_EDGES_EDGES_MASK] < 2) {
                     neighbour_list_push(neighbourList, 4, direction, tileElement->properties.path.ride_index, tileElement->properties.entrance.index);
                 } else {
-                    if (tile_element_get_type(initialTileElement) == TILE_ELEMENT_TYPE_PATH &&
+                    if ((initialTileElement)->GetType() == 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);
@@ -1390,7 +1390,7 @@ static void loc_6A6D7E(
     }
 
 loc_6A6FD2:
-    if (tile_element_get_type(initialTileElement) == TILE_ELEMENT_TYPE_PATH) {
+    if ((initialTileElement)->GetType() == TILE_ELEMENT_TYPE_PATH) {
         if (!query) {
             initialTileElement->properties.path.edges |= (1 << direction);
             map_invalidate_element(initialX, initialY, initialTileElement);
@@ -1405,13 +1405,13 @@ static void loc_6A6C85(
     if (query && fence_in_the_way(x, y, tileElement->base_height, tileElement->clearance_height, direction))
         return;
 
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE) {
         if (!entrance_has_direction(tileElement, direction - tile_element_get_direction(tileElement))) {
             return;
         }
     }
 
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK) {
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK) {
         Ride *ride = get_ride(track_element_get_ride_index(tileElement));
         if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
             return;
@@ -1428,7 +1428,7 @@ static void loc_6A6C85(
     }
 
     sint32 z = tileElement->base_height;
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH) {
         if (footpath_element_is_sloped(tileElement)) {
             if ((footpath_element_get_slope_direction(tileElement) - direction) & 1) {
                 return;
@@ -1462,7 +1462,7 @@ void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *tileElement, s
 
     neighbour_list_sort(&neighbourList);
 
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH && footpath_element_is_queue(tileElement)) {
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH && footpath_element_is_queue(tileElement)) {
         sint32 rideIndex = -1;
         uint8 entranceIndex = 255;
         for (size_t i = 0; i < neighbourList.count; i++) {
@@ -1487,7 +1487,7 @@ void footpath_connect_edges(sint32 x, sint32 y, rct_tile_element *tileElement, s
         loc_6A6C85(x, y, neighbour.direction, tileElement, flags, false, NULL);
     }
 
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH) {
         footpath_connect_corners(x, y, tileElement);
     }
 }
@@ -1505,7 +1505,7 @@ void footpath_chain_ride_queue(sint32 rideIndex, sint32 entranceIndex, sint32 x,
     lastQueuePathElement = nullptr;
     sint32 z = tileElement->base_height;
     for (;;) {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH) {
             lastPathElement = tileElement;
             lastPathX = x;
             lastPathY = y;
@@ -1523,7 +1523,7 @@ void footpath_chain_ride_queue(sint32 rideIndex, sint32 entranceIndex, sint32 x,
         do {
             if (lastQueuePathElement == tileElement)
                 continue;
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
                 continue;
             if (tileElement->base_height == z) {
                 if (footpath_element_is_sloped(tileElement)) {
@@ -1641,7 +1641,7 @@ void footpath_update_queue_chains()
             rct_tile_element * tileElement = map_get_first_element_at(location.x, location.y);
             do
             {
-                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+                if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
                     continue;
                 if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
                     continue;
@@ -1728,7 +1728,7 @@ static sint32 footpath_is_connected_to_map_edge_recurse(
 
     tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         if (
@@ -1940,7 +1940,7 @@ static void footpath_clear_wide(sint32 x, sint32 y)
     rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
         footpath_element_set_wide(tileElement, false);
     }
@@ -1957,7 +1957,7 @@ static rct_tile_element* footpath_can_be_wide(sint32 x, sint32 y, uint8 height)
 {
     rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
         if (height != tileElement->base_height)
             continue;
@@ -2008,7 +2008,7 @@ void footpath_update_path_wide_flags(sint32 x, sint32 y)
 
     rct_tile_element *tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         if (footpath_element_is_queue(tileElement))
@@ -2168,7 +2168,7 @@ void footpath_update_path_wide_flags(sint32 x, sint32 y)
  */
 void footpath_update_queue_entrance_banner(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    sint32 elementType = tile_element_get_type(tileElement);
+    sint32 elementType = tileElement->GetType();
     switch (elementType) {
     case TILE_ELEMENT_TYPE_PATH:
         if (footpath_element_is_queue(tileElement)) {
@@ -2218,7 +2218,7 @@ static void footpath_remove_edges_towards_here(sint32 x, sint32 y, sint32 z, sin
 
     tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
         if (tileElement->base_height != z)
             continue;
@@ -2244,7 +2244,7 @@ static void footpath_remove_edges_towards(sint32 x, sint32 y, sint32 z0, sint32
 
     tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         if (z1 == tileElement->base_height) {
@@ -2281,7 +2281,7 @@ bool tile_element_wants_path_connection_towards(TileCoordsXYZD coords, const rct
         if (tileElement == elementToBeRemoved)
             continue;
 
-        switch (tile_element_get_type(tileElement))
+        switch (tileElement->GetType())
         {
         case TILE_ELEMENT_TYPE_PATH:
             if (tileElement->base_height == coords.z)
@@ -2364,7 +2364,7 @@ static void footpath_fix_corners_around(sint32 x, sint32 y, rct_tile_element * p
             rct_tile_element * tileElement = map_get_first_element_at(x + xOffset, y + yOffset);
             do
             {
-                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+                if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
                     continue;
                 if (footpath_element_is_sloped(tileElement))
                     continue;
@@ -2387,7 +2387,7 @@ static void footpath_fix_corners_around(sint32 x, sint32 y, rct_tile_element * p
  */
 void footpath_remove_edges_at(sint32 x, sint32 y, rct_tile_element *tileElement)
 {
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK) {
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK) {
         sint32 rideIndex = track_element_get_ride_index(tileElement);
         Ride *ride = get_ride(rideIndex);
         if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
@@ -2399,7 +2399,7 @@ void footpath_remove_edges_at(sint32 x, sint32 y, rct_tile_element *tileElement)
     bool fixCorners = false;
     for (uint8 direction = 0; direction < 4; direction++) {
         sint32 z1 = tileElement->base_height;
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH) {
             if (footpath_element_is_sloped(tileElement)) {
                 sint32 slope = footpath_element_get_slope_direction(tileElement);
                 // Sloped footpaths don't connect sideways
@@ -2434,7 +2434,7 @@ void footpath_remove_edges_at(sint32 x, sint32 y, rct_tile_element *tileElement)
         footpath_fix_corners_around(x / 32, y / 32, tileElement);
     }
 
-    if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH)
+    if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH)
         tileElement->properties.path.edges = 0;
 }
 
diff --git a/src/openrct2/world/Fountain.cpp b/src/openrct2/world/Fountain.cpp
index 4e1aea1eb2..657eaffdd9 100644
--- a/src/openrct2/world/Fountain.cpp
+++ b/src/openrct2/world/Fountain.cpp
@@ -304,7 +304,7 @@ static bool is_jumping_fountain(sint32 type, sint32 x, sint32 y, sint32 z)
     rct_tile_element * tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH) continue;
+        if (tileElement->GetType() != 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;
diff --git a/src/openrct2/world/Map.cpp b/src/openrct2/world/Map.cpp
index bdc58e9042..fcc105f1dd 100644
--- a/src/openrct2/world/Map.cpp
+++ b/src/openrct2/world/Map.cpp
@@ -265,7 +265,7 @@ rct_tile_element * map_get_surface_element_at(sint32 x, sint32 y)
         return nullptr;
 
     // Find the first surface element
-    while (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SURFACE) {
+    while (tileElement->GetType() != TILE_ELEMENT_TYPE_SURFACE) {
         if (tile_element_is_last_for_tile(tileElement))
             return nullptr;
 
@@ -290,7 +290,7 @@ rct_tile_element* map_get_path_element_at(sint32 x, sint32 y, sint32 z){
     do {
         if (tileElement->flags & TILE_ELEMENT_FLAG_GHOST)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
         if (tileElement->base_height != z)
             continue;
@@ -309,7 +309,7 @@ rct_tile_element* map_get_banner_element_at(sint32 x, sint32 y, sint32 z, uint8
 
     // Find the banner element at known z and position
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_BANNER)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_BANNER)
             continue;
         if (tileElement->base_height != z)
             continue;
@@ -656,7 +656,7 @@ bool map_coord_is_connected(sint32 x, sint32 y, sint32 z, uint8 faceDirection)
     rct_tile_element *tileElement = map_get_first_element_at(x, y);
 
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         rct_tile_element_path_properties props = tileElement->properties.path;
@@ -847,7 +847,7 @@ void game_command_remove_large_scenery(
         return;
     }
     do {
-        if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_LARGE_SCENERY)
+        if (tile_element->GetType() != TILE_ELEMENT_TYPE_LARGE_SCENERY)
             continue;
 
         if (tile_element->base_height != base_height)
@@ -924,7 +924,7 @@ void game_command_remove_large_scenery(
         element_found = false;
         do
         {
-            if (tile_element_get_type(sceneryElement) != TILE_ELEMENT_TYPE_LARGE_SCENERY)
+            if (sceneryElement->GetType() != TILE_ELEMENT_TYPE_LARGE_SCENERY)
                 continue;
 
             if (tile_element_get_direction(sceneryElement) != tile_element_direction)
@@ -1074,7 +1074,7 @@ static money32 map_clear_scenery_from_tile(sint32 x, sint32 y, sint32 clear, sin
 restart_from_beginning:
     tileElement = map_get_first_element_at(x, y);
     do {
-        type = tile_element_get_type(tileElement);
+        type = tileElement->GetType();
         switch (type) {
         case TILE_ELEMENT_TYPE_PATH:
             if (clear & (1 << 2)) {
@@ -1160,7 +1160,7 @@ static void map_reset_clear_large_scenery_flag(){
         for (sint32 x = 0; x < MAXIMUM_MAP_SIZE_TECHNICAL; x++) {
             tileElement = map_get_first_element_at(x, y);
             do {
-                if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_LARGE_SCENERY) {
+                if (tileElement->GetType() == TILE_ELEMENT_TYPE_LARGE_SCENERY) {
                     tileElement->flags &= ~(1 << 6);
                 }
             } while (!tile_element_is_last_for_tile(tileElement++));
@@ -1413,10 +1413,10 @@ static sint32 map_set_land_height_clear_func(
     [[maybe_unused]] uint8     flags,
     [[maybe_unused]] money32 * price)
 {
-    if (tile_element_get_type(*tile_element) == TILE_ELEMENT_TYPE_SURFACE)
+    if ((*tile_element)->GetType() == TILE_ELEMENT_TYPE_SURFACE)
         return 0;
 
-    if (tile_element_get_type(*tile_element) == TILE_ELEMENT_TYPE_SMALL_SCENERY)
+    if ((*tile_element)->GetType() == TILE_ELEMENT_TYPE_SMALL_SCENERY)
         return 0;
 
     return 1;
@@ -1526,7 +1526,7 @@ static money32 map_set_land_height(sint32 flags, sint32 x, sint32 y, sint32 heig
         //Check for obstructing scenery
         tileElement = map_get_first_element_at(x / 32, y / 32);
         do {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
                 continue;
             if (height > tileElement->clearance_height)
                 continue;
@@ -1550,7 +1550,7 @@ static money32 map_set_land_height(sint32 flags, sint32 x, sint32 y, sint32 heig
         tileElement = map_get_first_element_at(x / 32, y / 32);
         do
         {
-            if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_TRACK)
+            if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
             {
                 sint32 rideIndex = track_element_get_ride_index(tileElement);
                 Ride * ride = get_ride(rideIndex);
@@ -1620,7 +1620,7 @@ static money32 map_set_land_height(sint32 flags, sint32 x, sint32 y, sint32 heig
     if (!gCheatsDisableClearanceChecks) {
         tileElement = map_get_first_element_at(x / 32, y / 32);
         do {
-            sint32 elementType = tile_element_get_type(tileElement);
+            sint32 elementType = tileElement->GetType();
 
             if (elementType == TILE_ELEMENT_TYPE_WALL)
                 continue;
@@ -2933,7 +2933,7 @@ void map_remove_all_rides()
 
     tile_element_iterator_begin(&it);
     do {
-        switch (tile_element_get_type(it.element)) {
+        switch (it.element->GetType()) {
         case TILE_ELEMENT_TYPE_PATH:
             if (footpath_element_is_queue(it.element))
             {
@@ -3169,7 +3169,7 @@ void map_obstruction_set_error_text(rct_tile_element *tileElement)
     rct_scenery_entry *sceneryEntry;
 
     errorStringId = STR_OBJECT_IN_THE_WAY;
-    switch (tile_element_get_type(tileElement)) {
+    switch (tileElement->GetType()) {
     case TILE_ELEMENT_TYPE_SURFACE:
         errorStringId = STR_RAISE_OR_LOWER_LAND_FIRST;
         break;
@@ -3239,7 +3239,7 @@ sint32 map_can_construct_with_clear_at(sint32 x, sint32 y, sint32 zLow, sint32 z
     }
     rct_tile_element* tile_element = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_SURFACE) {
+        if (tile_element->GetType() != TILE_ELEMENT_TYPE_SURFACE) {
             if (zLow < tile_element->clearance_height && zHigh > tile_element->base_height && !(tile_element->flags & TILE_ELEMENT_FLAG_GHOST)) {
                 if (tile_element->flags & (bl & 0x0F)) {
                     goto loc_68BABC;
@@ -3266,7 +3266,7 @@ sint32 map_can_construct_with_clear_at(sint32 x, sint32 y, sint32 zLow, sint32 z
         }
 
         // Only allow building crossings directly on a flat surface tile.
-        if (tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_SURFACE &&
+        if (tile_element->GetType() == TILE_ELEMENT_TYPE_SURFACE &&
             (tile_element->properties.surface.slope & TILE_ELEMENT_SURFACE_SLOPE_MASK) == TILE_ELEMENT_SLOPE_FLAT &&
             tile_element->base_height == zLow)
         {
@@ -3321,7 +3321,7 @@ sint32 map_can_construct_with_clear_at(sint32 x, sint32 y, sint32 zLow, sint32 z
                 // Crossing mode 1: building track over path
                 if (crossingMode == 1 &&
                     canBuildCrossing &&
-                    tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_PATH &&
+                    tile_element->GetType() == TILE_ELEMENT_TYPE_PATH &&
                     tile_element->base_height == zLow &&
                     !footpath_element_is_queue(tile_element) &&
                     !footpath_element_is_sloped(tile_element))
@@ -3331,7 +3331,7 @@ sint32 map_can_construct_with_clear_at(sint32 x, sint32 y, sint32 zLow, sint32 z
                 // Crossing mode 2: building path over track
                 else if (crossingMode == 2 &&
                      canBuildCrossing &&
-                     tile_element_get_type(tile_element) == TILE_ELEMENT_TYPE_TRACK &&
+                     tile_element->GetType() == TILE_ELEMENT_TYPE_TRACK &&
                      tile_element->base_height == zLow &&
                      track_element_get_type(tile_element) == TRACK_ELEM_FLAT)
                 {
@@ -3463,7 +3463,7 @@ static void map_update_grass_length(sint32 x, sint32 y, rct_tile_element *tileEl
             }
         } else {
             tileElementAbove++;
-            if (tile_element_get_type(tileElementAbove) == TILE_ELEMENT_TYPE_WALL)
+            if (tileElementAbove->GetType() == TILE_ELEMENT_TYPE_WALL)
                 continue;
             // Grass should not be affected by ghost elements.
             if (tile_element_is_ghost(tileElementAbove))
@@ -3643,7 +3643,7 @@ void map_extend_boundary_surface()
 static void clear_element_at(sint32 x, sint32 y, rct_tile_element **elementPtr)
 {
     rct_tile_element *element = *elementPtr;
-    switch (tile_element_get_type(element)) {
+    switch (element->GetType()) {
     case TILE_ELEMENT_TYPE_SURFACE:
         element->base_height = 2;
         element->clearance_height = 2;
@@ -3753,7 +3753,7 @@ rct_tile_element *map_get_large_scenery_segment(sint32 x, sint32 y, sint32 z, si
         return nullptr;
     }
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_LARGE_SCENERY)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_LARGE_SCENERY)
             continue;
         if (tileElement->base_height != z)
             continue;
@@ -3774,7 +3774,7 @@ rct_tile_element * map_get_park_entrance_element_at(sint32 x, sint32 y, sint32 z
     {
         do
         {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
 
             if (tileElement->base_height != z)
@@ -3800,7 +3800,7 @@ rct_tile_element * map_get_ride_entrance_element_at(sint32 x, sint32 y, sint32 z
     {
         do
         {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
 
             if (tileElement->base_height != z)
@@ -3826,7 +3826,7 @@ rct_tile_element * map_get_ride_exit_element_at(sint32 x, sint32 y, sint32 z, bo
     {
         do
         {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
 
             if (tileElement->base_height != z)
@@ -3852,7 +3852,7 @@ rct_tile_element *map_get_small_scenery_element_at(sint32 x, sint32 y, sint32 z,
     {
         do
         {
-            if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
                 continue;
             if (tileElement->type >> 6 != quadrant)
                 continue;
@@ -4133,11 +4133,11 @@ bool map_surface_is_blocked(sint16 x, sint16 y){
         if (base_z < tileElement->base_height)
             continue;
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH ||
-            tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_PATH ||
+            tileElement->GetType() == TILE_ELEMENT_TYPE_WALL)
             continue;
 
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
             return true;
 
         rct_scenery_entry* scenery = get_small_scenery_entry(tileElement->properties.scenery.type);
@@ -4187,7 +4187,7 @@ void game_command_set_sign_style(
         rct_tile_element* tile_element = map_get_first_element_at(x / 32, y / 32);
         bool wall_found = false;
         do{
-            if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_WALL)
+            if (tile_element->GetType() != TILE_ELEMENT_TYPE_WALL)
                 continue;
 
             rct_scenery_entry* scenery_entry = get_wall_entry(tile_element->properties.wall.type);
@@ -4214,7 +4214,7 @@ void game_command_set_sign_style(
         map_invalidate_tile(x, y, tile_element->base_height * 8, tile_element->clearance_height * 8);
     } else { // large sign
         rct_tile_element *tileElement = banner_get_tile_element(bannerId);
-        if (tileElement == nullptr || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_LARGE_SCENERY) {
+        if (tileElement == nullptr || tileElement->GetType() != TILE_ELEMENT_TYPE_LARGE_SCENERY) {
             gGameCommandErrorText = STR_ERR_CANT_SET_BANNER_TEXT;
             *ebx = MONEY32_UNDEFINED;
             return;
@@ -4417,7 +4417,7 @@ rct_tile_element *map_get_track_element_at(sint32 x, sint32 y, sint32 z)
 {
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
         if (tileElement->base_height != z) continue;
 
         return tileElement;
@@ -4437,7 +4437,7 @@ rct_tile_element *map_get_track_element_at_of_type(sint32 x, sint32 y, sint32 z,
 {
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
         if (tileElement->base_height != z) continue;
         if (track_element_get_type(tileElement) != trackType) continue;
 
@@ -4460,7 +4460,7 @@ rct_tile_element *map_get_track_element_at_of_type_seq(sint32 x, sint32 y, sint3
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
         if (tileElement == nullptr) break;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
         if (tileElement->base_height != z) continue;
         if (track_element_get_type(tileElement) != trackType) continue;
         if (tile_element_get_track_sequence(tileElement) != sequence) continue;
@@ -4482,7 +4482,7 @@ rct_tile_element *map_get_track_element_at_of_type_seq(sint32 x, sint32 y, sint3
 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 *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
         if (tileElement->base_height != z) continue;
         if (track_element_get_ride_index(tileElement) != rideIndex) continue;
         if (track_element_get_type(tileElement) != trackType) continue;
@@ -4503,7 +4503,7 @@ rct_tile_element *map_get_track_element_at_of_type_from_ride(sint32 x, sint32 y,
 rct_tile_element *map_get_track_element_at_from_ride(sint32 x, sint32 y, sint32 z, sint32 rideIndex) {
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
         if (tileElement->base_height != z) continue;
         if (track_element_get_ride_index(tileElement) != rideIndex) continue;
 
@@ -4525,7 +4525,7 @@ rct_tile_element *map_get_track_element_at_with_direction_from_ride(sint32 x, si
 {
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK) continue;
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK) continue;
         if (tileElement->base_height != z) continue;
         if (track_element_get_ride_index(tileElement) != rideIndex) continue;
         if (tile_element_get_direction(tileElement) != direction) continue;
@@ -4562,7 +4562,7 @@ rct_tile_element *map_get_wall_element_at(sint32 x, sint32 y, sint32 z, sint32 d
 {
     rct_tile_element *tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
         if (tileElement->base_height != z)
             continue;
@@ -4598,7 +4598,7 @@ uint16 check_max_allowable_land_rights_for_tile(uint8 x, uint8 y, uint8 base_z)
 
     do
     {
-        sint32 type = tile_element_get_type(tileElement);
+        sint32 type = tileElement->GetType();
         if (type == TILE_ELEMENT_TYPE_PATH ||
             (type == TILE_ELEMENT_TYPE_ENTRANCE && tileElement->properties.entrance.type == ENTRANCE_TYPE_PARK_ENTRANCE))
         {
diff --git a/src/openrct2/world/MapAnimation.cpp b/src/openrct2/world/MapAnimation.cpp
index 66600a9a88..47135a89f3 100644
--- a/src/openrct2/world/MapAnimation.cpp
+++ b/src/openrct2/world/MapAnimation.cpp
@@ -110,7 +110,7 @@ static bool map_animation_invalidate_ride_entrance(sint32 x, sint32 y, sint32 ba
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
         if (tileElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
             continue;
@@ -138,7 +138,7 @@ static bool map_animation_invalidate_queue_banner(sint32 x, sint32 y, sint32 bas
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
         if (!(tileElement->flags & 1))
             continue;
@@ -171,7 +171,7 @@ static bool map_animation_invalidate_small_scenery(sint32 x, sint32 y, sint32 ba
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
             continue;
         if (tileElement->flags & (1 << 4))
             continue;
@@ -233,7 +233,7 @@ static bool map_animation_invalidate_park_entrance(sint32 x, sint32 y, sint32 ba
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
             continue;
         if (tileElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
             continue;
@@ -260,7 +260,7 @@ static bool map_animation_invalidate_track_waterfall(sint32 x, sint32 y, sint32
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_type(tileElement) == TRACK_ELEM_WATERFALL) {
@@ -285,7 +285,7 @@ static bool map_animation_invalidate_track_rapids(sint32 x, sint32 y, sint32 bas
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_type(tileElement) == TRACK_ELEM_RAPIDS) {
@@ -312,7 +312,7 @@ static bool map_animation_invalidate_track_onridephoto(sint32 x, sint32 y, sint3
             break;
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_type(tileElement) == TRACK_ELEM_ON_RIDE_PHOTO) {
@@ -344,7 +344,7 @@ static bool map_animation_invalidate_track_whirlpool(sint32 x, sint32 y, sint32
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_type(tileElement) == TRACK_ELEM_WHIRLPOOL) {
@@ -369,7 +369,7 @@ static bool map_animation_invalidate_track_spinningtunnel(sint32 x, sint32 y, si
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
             continue;
 
         if (track_element_get_type(tileElement) == TRACK_ELEM_SPINNING_TUNNEL) {
@@ -403,7 +403,7 @@ static bool map_animation_invalidate_banner(sint32 x, sint32 y, sint32 baseZ)
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_BANNER)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_BANNER)
             continue;
 
         baseZ = tileElement->base_height * 8;
@@ -428,7 +428,7 @@ static bool map_animation_invalidate_large_scenery(sint32 x, sint32 y, sint32 ba
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_LARGE_SCENERY)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_LARGE_SCENERY)
             continue;
 
         sceneryEntry = get_large_scenery_entry(tileElement->properties.scenery.type & 0x3FF);
@@ -459,7 +459,7 @@ static bool map_animation_invalidate_wall_door(sint32 x, sint32 y, sint32 baseZ)
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
 
         sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
@@ -511,7 +511,7 @@ static bool map_animation_invalidate_wall(sint32 x, sint32 y, sint32 baseZ)
     do {
         if (tileElement->base_height != baseZ)
             continue;
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
 
         sceneryEntry = get_wall_entry(tileElement->properties.scenery.type);
diff --git a/src/openrct2/world/Park.cpp b/src/openrct2/world/Park.cpp
index 5b958fcd7f..6f6e2ce41c 100644
--- a/src/openrct2/world/Park.cpp
+++ b/src/openrct2/world/Park.cpp
@@ -174,7 +174,7 @@ sint32 park_calculate_size()
     tiles = 0;
     tile_element_iterator_begin(&it);
     do {
-        if (tile_element_get_type(it.element) == TILE_ELEMENT_TYPE_SURFACE) {
+        if (it.element->GetType() == TILE_ELEMENT_TYPE_SURFACE) {
             if (it.element->properties.surface.ownership & (OWNERSHIP_CONSTRUCTION_RIGHTS_OWNED | OWNERSHIP_OWNED)) {
                 tiles++;
             }
@@ -730,7 +730,7 @@ void update_park_fences(sint32 x, sint32 y)
         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(tileElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+            if (tileElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
                 continue;
 
             if (tileElement->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
@@ -879,7 +879,7 @@ static money32 map_buy_land_rights_for_tile(sint32 x, sint32 y, sint32 setting,
 
             rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
             do {
-                if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE) {
+                if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE) {
                     // Do not allow ownership of park entrance.
                     if (newOwnership == OWNERSHIP_OWNED || newOwnership == OWNERSHIP_AVAILABLE)
                         return 0;
diff --git a/src/openrct2/world/Scenery.cpp b/src/openrct2/world/Scenery.cpp
index e0b80b214d..572eda9071 100644
--- a/src/openrct2/world/Scenery.cpp
+++ b/src/openrct2/world/Scenery.cpp
@@ -92,9 +92,9 @@ void scenery_update_tile(sint32 x, sint32 y)
                 continue;
         }
 
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_SMALL_SCENERY) {
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_SMALL_SCENERY) {
             scenery_update_age(x, y, tileElement);
-        } else if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_PATH) {
+        } else if (tileElement->GetType() == 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 != nullptr) {
@@ -150,7 +150,7 @@ void scenery_update_age(sint32 x, sint32 y, rct_tile_element *tileElement)
         if (tile_element_is_ghost(tileElementAbove))
             continue;
 
-        switch (tile_element_get_type(tileElementAbove)) {
+        switch (tileElementAbove->GetType()) {
         case TILE_ELEMENT_TYPE_LARGE_SCENERY:
         case TILE_ELEMENT_TYPE_ENTRANCE:
         case TILE_ELEMENT_TYPE_PATH:
@@ -224,7 +224,7 @@ void scenery_remove_ghost_tool_placement(){
 
         do
         {
-            if (tile_element_get_type(tile_element) != TILE_ELEMENT_TYPE_PATH)
+            if (tile_element->GetType() != TILE_ELEMENT_TYPE_PATH)
                 continue;
 
             if (tile_element->base_height != z)
diff --git a/src/openrct2/world/SmallScenery.cpp b/src/openrct2/world/SmallScenery.cpp
index 8b7ed4bd25..aca84a92d8 100644
--- a/src/openrct2/world/SmallScenery.cpp
+++ b/src/openrct2/world/SmallScenery.cpp
@@ -80,7 +80,7 @@ static money32 SmallSceneryRemove(sint16 x, sint16 y, uint8 baseHeight, uint8 qu
     bool sceneryFound = false;
     rct_tile_element* tileElement = map_get_first_element_at(x / 32, y / 32);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
             continue;
         if ((tileElement->type >> 6) != quadrant)
             continue;
@@ -494,7 +494,7 @@ void game_command_set_scenery_colour(
  */
 sint32 map_place_scenery_clear_func(rct_tile_element** tile_element, sint32 x, sint32 y, uint8 flags, money32* price)
 {
-    if (tile_element_get_type(*tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+    if ((*tile_element)->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
         return 1;
 
     if (!(flags & GAME_COMMAND_FLAG_PATH_SCENERY))
@@ -531,7 +531,7 @@ sint32 map_place_scenery_clear_func(rct_tile_element** tile_element, sint32 x, s
  */
 sint32 map_place_non_scenery_clear_func(rct_tile_element** tile_element, sint32 x, sint32 y, uint8 flags, money32* price)
 {
-    if (tile_element_get_type(*tile_element) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+    if ((*tile_element)->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
         return 1;
 
     rct_scenery_entry* scenery = get_small_scenery_entry((*tile_element)->properties.scenery.type);
diff --git a/src/openrct2/world/Sprite.cpp b/src/openrct2/world/Sprite.cpp
index 7501c0b728..8657649d3f 100644
--- a/src/openrct2/world/Sprite.cpp
+++ b/src/openrct2/world/Sprite.cpp
@@ -649,7 +649,7 @@ static bool litter_can_be_at(sint32 x, sint32 y, sint32 z)
 
     tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_PATH)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
         sint32 pathZ = tileElement->base_height * 8;
diff --git a/src/openrct2/world/TileElement.cpp b/src/openrct2/world/TileElement.cpp
index 35b58a6b3a..41e741d751 100644
--- a/src/openrct2/world/TileElement.cpp
+++ b/src/openrct2/world/TileElement.cpp
@@ -65,11 +65,6 @@ uint8 rct_tile_element::GetSceneryQuadrant() const
     return (this->type & TILE_ELEMENT_QUADRANT_MASK) >> 6;
 }
 
-sint32 tile_element_get_type(const rct_tile_element * element)
-{
-    return element->GetType();
-}
-
 sint32 tile_element_get_direction(const rct_tile_element * element)
 {
     return element->GetDirection();
@@ -91,7 +86,7 @@ bool tile_element_is_underground(rct_tile_element * tileElement)
         tileElement++;
         if (tile_element_is_last_for_tile(tileElement - 1))
             return false;
-    } while (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SURFACE);
+    } while (tileElement->GetType() != TILE_ELEMENT_TYPE_SURFACE);
     return true;
 }
 
@@ -104,7 +99,7 @@ sint32 tile_element_get_banner_index(rct_tile_element * tileElement)
 {
     rct_scenery_entry* sceneryEntry;
 
-    switch (tile_element_get_type(tileElement)) {
+    switch (tileElement->GetType()) {
     case TILE_ELEMENT_TYPE_LARGE_SCENERY:
         sceneryEntry = get_large_scenery_entry(scenery_large_get_type(tileElement));
         if (sceneryEntry->large_scenery.scrolling_mode == 0xFF)
@@ -126,7 +121,7 @@ sint32 tile_element_get_banner_index(rct_tile_element * tileElement)
 
 void tile_element_set_banner_index(rct_tile_element * tileElement, sint32 bannerIndex)
 {
-    switch (tile_element_get_type(tileElement))
+    switch (tileElement->GetType())
     {
     case TILE_ELEMENT_TYPE_WALL:
         tileElement->properties.wall.banner_index = (uint8)bannerIndex;
@@ -159,7 +154,7 @@ void tile_element_remove_banner_entry(rct_tile_element * tileElement)
 
 uint8 tile_element_get_ride_index(const rct_tile_element * tileElement)
 {
-    switch (tile_element_get_type(tileElement))
+    switch (tileElement->GetType())
     {
     case TILE_ELEMENT_TYPE_TRACK:
         return track_element_get_ride_index(tileElement);
diff --git a/src/openrct2/world/TileElement.h b/src/openrct2/world/TileElement.h
index e062b08364..db31aa3ccb 100644
--- a/src/openrct2/world/TileElement.h
+++ b/src/openrct2/world/TileElement.h
@@ -207,7 +207,6 @@ enum
 #define MAP_ELEM_TRACK_SEQUENCE_SEQUENCE_MASK      0b00001111
 #define MAP_ELEM_TRACK_SEQUENCE_TAKING_PHOTO_MASK  0b11110000
 
-sint32 tile_element_get_type(const rct_tile_element * element);
 sint32 tile_element_get_direction(const rct_tile_element * element);
 sint32 tile_element_get_direction_with_offset(const rct_tile_element * element, uint8 offset);
 sint32 tile_element_get_banner_index(rct_tile_element * tileElement);
diff --git a/src/openrct2/world/TileInspector.cpp b/src/openrct2/world/TileInspector.cpp
index 200ba49972..0ed79e9ce9 100644
--- a/src/openrct2/world/TileInspector.cpp
+++ b/src/openrct2/world/TileInspector.cpp
@@ -240,7 +240,7 @@ sint32 tile_inspector_rotate_element_at(sint32 x, sint32 y, sint32 elementIndex,
         {
             return MONEY32_UNDEFINED;
         }
-        switch (tile_element_get_type(tileElement))
+        switch (tileElement->GetType())
         {
         case TILE_ELEMENT_TYPE_PATH:
             if (footpath_element_is_sloped(tileElement))
@@ -454,7 +454,7 @@ sint32 tile_inspector_any_base_height_offset(sint32 x, sint32 y, sint16 elementI
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
     {
-        if (tile_element_get_type(tileElement) == TILE_ELEMENT_TYPE_ENTRANCE)
+        if (tileElement->GetType() == TILE_ELEMENT_TYPE_ENTRANCE)
         {
             uint8 entranceType = tileElement->properties.entrance.type;
             if (entranceType != ENTRANCE_TYPE_PARK_ENTRANCE)
@@ -622,7 +622,7 @@ sint32 tile_inspector_path_set_sloped(sint32 x, sint32 y, sint32 elementIndex, b
 {
     rct_tile_element * const pathElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (pathElement == nullptr || tile_element_get_type(pathElement) != TILE_ELEMENT_TYPE_PATH)
+    if (pathElement == nullptr || pathElement->GetType() != TILE_ELEMENT_TYPE_PATH)
         return MONEY32_UNDEFINED;
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
@@ -649,7 +649,7 @@ sint32 tile_inspector_path_toggle_edge(sint32 x, sint32 y, sint32 elementIndex,
 {
     rct_tile_element * const pathElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (pathElement == nullptr || tile_element_get_type(pathElement) != TILE_ELEMENT_TYPE_PATH)
+    if (pathElement == nullptr || pathElement->GetType() != TILE_ELEMENT_TYPE_PATH)
         return MONEY32_UNDEFINED;
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
@@ -672,7 +672,7 @@ sint32 tile_inspector_entrance_make_usable(sint32 x, sint32 y, sint32 elementInd
 {
     rct_tile_element * const entranceElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (entranceElement == nullptr || tile_element_get_type(entranceElement) != TILE_ELEMENT_TYPE_ENTRANCE)
+    if (entranceElement == nullptr || entranceElement->GetType() != TILE_ELEMENT_TYPE_ENTRANCE)
         return MONEY32_UNDEFINED;
 
     Ride * ride = get_ride(entranceElement->properties.entrance.ride_index);
@@ -708,7 +708,7 @@ sint32 tile_inspector_wall_set_slope(sint32 x, sint32 y, sint32 elementIndex, si
 {
     rct_tile_element * const wallElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (wallElement == nullptr || tile_element_get_type(wallElement) != TILE_ELEMENT_TYPE_WALL)
+    if (wallElement == nullptr || wallElement->GetType() != TILE_ELEMENT_TYPE_WALL)
         return MONEY32_UNDEFINED;
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
@@ -738,7 +738,7 @@ sint32 tile_inspector_track_base_height_offset(sint32 x, sint32 y, sint32 elemen
     if (offset == 0)
         return 0;
 
-    if (trackElement == nullptr || tile_element_get_type(trackElement) != TILE_ELEMENT_TYPE_TRACK)
+    if (trackElement == nullptr || trackElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
         return MONEY32_UNDEFINED;
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
@@ -812,7 +812,7 @@ sint32 tile_inspector_track_base_height_offset(sint32 x, sint32 y, sint32 elemen
                 if (tileElement->base_height != elemZ / 8)
                     continue;
 
-                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+                if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                     continue;
 
                 if ((tile_element_get_direction(tileElement)) != rotation)
@@ -860,7 +860,7 @@ sint32 tile_inspector_track_set_chain(sint32 x, sint32 y, sint32 elementIndex, b
 {
     rct_tile_element * const trackElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (trackElement == nullptr || tile_element_get_type(trackElement) != TILE_ELEMENT_TYPE_TRACK)
+    if (trackElement == nullptr || trackElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
         return MONEY32_UNDEFINED;
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
@@ -945,7 +945,7 @@ sint32 tile_inspector_track_set_chain(sint32 x, sint32 y, sint32 elementIndex, b
                 if (tileElement->base_height != elemZ / 8)
                     continue;
 
-                if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_TRACK)
+                if (tileElement->GetType() != TILE_ELEMENT_TYPE_TRACK)
                     continue;
 
                 if ((tile_element_get_direction(tileElement)) != rotation)
@@ -992,7 +992,7 @@ sint32 tile_inspector_scenery_set_quarter_location(sint32 x, sint32 y, sint32 el
 {
     rct_tile_element * const tileElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (tileElement == nullptr || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+    if (tileElement == nullptr || tileElement->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
         return MONEY32_UNDEFINED;
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
@@ -1019,7 +1019,7 @@ sint32 tile_inspector_scenery_set_quarter_collision(sint32 x, sint32 y, sint32 e
 {
     rct_tile_element * const tileElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (tileElement == nullptr || tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_SMALL_SCENERY)
+    if (tileElement == nullptr || tileElement->GetType() != TILE_ELEMENT_TYPE_SMALL_SCENERY)
         return MONEY32_UNDEFINED;
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
@@ -1040,7 +1040,7 @@ sint32 tile_inspector_banner_toggle_blocking_edge(sint32 x, sint32 y, sint32 ele
 {
     rct_tile_element * const bannerElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (bannerElement == nullptr || tile_element_get_type(bannerElement) != TILE_ELEMENT_TYPE_BANNER)
+    if (bannerElement == nullptr || bannerElement->GetType() != TILE_ELEMENT_TYPE_BANNER)
         return MONEY32_UNDEFINED;
 
     if (flags & GAME_COMMAND_FLAG_APPLY)
@@ -1060,7 +1060,7 @@ sint32 tile_inspector_corrupt_clamp(sint32 x, sint32 y, sint32 elementIndex, sin
 {
     rct_tile_element * const corruptElement = map_get_nth_element_at(x, y, elementIndex);
 
-    if (corruptElement == nullptr || tile_element_get_type(corruptElement) != TILE_ELEMENT_TYPE_CORRUPT)
+    if (corruptElement == nullptr || corruptElement->GetType() != TILE_ELEMENT_TYPE_CORRUPT)
         return MONEY32_UNDEFINED;
 
     if (tile_element_is_last_for_tile(corruptElement))
diff --git a/src/openrct2/world/Wall.cpp b/src/openrct2/world/Wall.cpp
index a77ccb1f98..0cc756c653 100644
--- a/src/openrct2/world/Wall.cpp
+++ b/src/openrct2/world/Wall.cpp
@@ -186,7 +186,7 @@ static bool WallCheckObstruction(rct_scenery_entry * wall,
     rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        sint32 elementType = tile_element_get_type(tileElement);
+        sint32 elementType = tileElement->GetType();
         if (elementType == TILE_ELEMENT_TYPE_SURFACE) continue;
         if (z0 >= tileElement->clearance_height) continue;
         if (z1 <= tileElement->base_height) continue;
@@ -582,7 +582,7 @@ static rct_tile_element * GetFirstWallElementAt(sint32 x, sint32 y, uint8 baseZ,
     rct_tile_element * tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL) continue;
+        if (tileElement->GetType() != 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;
@@ -753,7 +753,7 @@ repeat:
     tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
         if (z0 >= tileElement->clearance_height)
             continue;
@@ -788,7 +788,7 @@ void wall_remove_intersecting_walls(sint32 x, sint32 y, sint32 z0, sint32 z1, si
     tileElement = map_get_first_element_at(x >> 5, y >> 5);
     do
     {
-        if (tile_element_get_type(tileElement) != TILE_ELEMENT_TYPE_WALL)
+        if (tileElement->GetType() != TILE_ELEMENT_TYPE_WALL)
             continue;
 
         if (tileElement->clearance_height <= z0 || tileElement->base_height >= z1)
diff --git a/test/testpaint/Compat.cpp b/test/testpaint/Compat.cpp
index 9ad3453ac0..e8618dcbb3 100644
--- a/test/testpaint/Compat.cpp
+++ b/test/testpaint/Compat.cpp
@@ -127,8 +127,9 @@ bool tile_element_is_last_for_tile(const rct_tile_element *element) {
     return (element->flags & TILE_ELEMENT_FLAG_LAST_TILE) != 0;
 }
 
-int tile_element_get_type(const rct_tile_element *element) {
-    return element->type & TILE_ELEMENT_TYPE_MASK;
+uint8 rct_tile_element::GetType() const
+{
+    return this->type & TILE_ELEMENT_TYPE_MASK;
 }
 
 int tile_element_get_direction(const rct_tile_element *element) {