diff --git a/src/openrct2/core/DataSerialiserTraits.h b/src/openrct2/core/DataSerialiserTraits.h
index 747ae46659..cf032848af 100644
--- a/src/openrct2/core/DataSerialiserTraits.h
+++ b/src/openrct2/core/DataSerialiserTraits.h
@@ -430,7 +430,7 @@ template<> struct DataSerializerTraits<TileElement>
     static void encode(IStream* stream, const TileElement& tileElement)
     {
         stream->WriteValue(tileElement.type);
-        stream->WriteValue(tileElement.flags);
+        stream->WriteValue(tileElement.Flags);
         stream->WriteValue(tileElement.base_height);
         stream->WriteValue(tileElement.clearance_height);
         for (int i = 0; i < 4; ++i)
@@ -445,7 +445,7 @@ template<> struct DataSerializerTraits<TileElement>
     static void decode(IStream* stream, TileElement& tileElement)
     {
         tileElement.type = stream->ReadValue<uint8_t>();
-        tileElement.flags = stream->ReadValue<uint8_t>();
+        tileElement.Flags = stream->ReadValue<uint8_t>();
         tileElement.base_height = stream->ReadValue<uint8_t>();
         tileElement.clearance_height = stream->ReadValue<uint8_t>();
         for (int i = 0; i < 4; ++i)
@@ -461,7 +461,7 @@ template<> struct DataSerializerTraits<TileElement>
     {
         char msg[128] = {};
         snprintf(
-            msg, sizeof(msg), "TileElement(type = %u, flags = %u, base_height = %u)", tileElement.type, tileElement.flags,
+            msg, sizeof(msg), "TileElement(type = %u, flags = %u, base_height = %u)", tileElement.type, tileElement.Flags,
             tileElement.base_height);
         stream->Write(msg, strlen(msg));
     }
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index af927e087c..345f480a3b 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -1988,7 +1988,12 @@ private:
         uint8_t tileElementType = src->GetType();
         dst->ClearAs(tileElementType);
         dst->SetDirection(src->GetDirection());
-        dst->flags = src->flags;
+
+        // All saved in "flags"
+        dst->SetOccupiedQuadrants(src->GetOccupiedQuadrants());
+        dst->SetGhost(src->IsGhost());
+        dst->SetLastForTile(src->IsLastForTile());
+
         dst->SetBaseZ(src->base_height * 4);
         dst->SetClearanceZ(src->clearance_height * 4);
 
@@ -2097,6 +2102,7 @@ private:
                 dst2->SetDoorBState(src2->GetDoorBState());
                 dst2->SetStationIndex(src2->GetStationIndex());
                 dst2->SetHasGreenLight(src2->HasGreenLight());
+                dst2->SetIsIndestructible(src2->IsIndestructible());
 
                 auto trackType = dst2->GetTrackType();
                 if (track_element_has_speed_setting(trackType))
diff --git a/src/openrct2/rct12/RCT12.cpp b/src/openrct2/rct12/RCT12.cpp
index 755b207ec7..485bb9a198 100644
--- a/src/openrct2/rct12/RCT12.cpp
+++ b/src/openrct2/rct12/RCT12.cpp
@@ -29,6 +29,17 @@ uint8_t RCT12TileElementBase::GetDirection() const
     return this->type & TILE_ELEMENT_DIRECTION_MASK;
 }
 
+uint8_t RCT12TileElementBase::GetOccupiedQuadrants() const
+{
+    return flags & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK;
+}
+
+void RCT12TileElementBase::SetOccupiedQuadrants(uint8_t quadrants)
+{
+    flags &= ~TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK;
+    flags |= (quadrants & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK);
+}
+
 bool RCT12TileElementBase::IsLastForTile() const
 {
     return (this->flags & TILE_ELEMENT_FLAG_LAST_TILE) != 0;
@@ -39,6 +50,26 @@ bool RCT12TileElementBase::IsGhost() const
     return (this->flags & TILE_ELEMENT_FLAG_GHOST) != 0;
 }
 
+void RCT12TileElementBase::SetLastForTile(bool on)
+{
+    if (on)
+        flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+    else
+        flags &= ~TILE_ELEMENT_FLAG_LAST_TILE;
+}
+
+void RCT12TileElementBase::SetGhost(bool isGhost)
+{
+    if (isGhost)
+    {
+        this->flags |= TILE_ELEMENT_FLAG_GHOST;
+    }
+    else
+    {
+        this->flags &= ~TILE_ELEMENT_FLAG_GHOST;
+    }
+}
+
 uint8_t RCT12SurfaceElement::GetSlope() const
 {
     return (slope & TILE_ELEMENT_SURFACE_SLOPE_MASK);
@@ -259,6 +290,23 @@ uint8_t RCT12TrackElement::GetDoorBState() const
     return (colour & RCT12_TRACK_ELEMENT_DOOR_B_MASK) >> 5;
 }
 
+bool RCT12TrackElement::IsIndestructible() const
+{
+    return (flags & RCT12_TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE) != 0;
+}
+
+void RCT12TrackElement::SetIsIndestructible(bool isIndestructible)
+{
+    if (isIndestructible)
+    {
+        flags |= RCT12_TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE;
+    }
+    else
+    {
+        flags &= ~RCT12_TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE;
+    }
+}
+
 uint8_t RCT12SmallSceneryElement::GetEntryIndex() const
 {
     return this->entryIndex;
@@ -695,6 +743,40 @@ void RCT12PathElement::SetAdditionIsGhost(bool isGhost)
         additions |= RCT12_FOOTPATH_PROPERTIES_ADDITIONS_FLAG_GHOST;
 }
 
+bool RCT12PathElement::IsBroken() const
+{
+    return (flags & RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE) != 0;
+}
+
+void RCT12PathElement::SetIsBroken(bool isBroken)
+{
+    if (isBroken)
+    {
+        flags |= RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE;
+    }
+    else
+    {
+        flags &= ~RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE;
+    }
+}
+
+bool RCT12PathElement::IsBlockedByVehicle() const
+{
+    return (flags & RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE) != 0;
+}
+
+void RCT12PathElement::SetIsBlockedByVehicle(bool isBlocked)
+{
+    if (isBlocked)
+    {
+        flags |= RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE;
+    }
+    else
+    {
+        flags &= ~RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE;
+    }
+}
+
 void RCT12TrackElement::SetTrackType(uint8_t newType)
 {
     trackType = newType;
@@ -754,15 +836,20 @@ void RCT12TrackElement::SetBrakeBoosterSpeed(uint8_t speed)
     }
 }
 
+bool RCT12TrackElement::BlockBrakeClosed() const
+{
+    return (flags & RCT12_TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED) != 0;
+}
+
 void RCT12TrackElement::SetBlockBrakeClosed(bool isClosed)
 {
     if (isClosed)
     {
-        flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
+        flags |= RCT12_TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
     }
     else
     {
-        flags &= ~TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
+        flags &= ~RCT12_TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
     }
 }
 
diff --git a/src/openrct2/rct12/RCT12.h b/src/openrct2/rct12/RCT12.h
index e2f6b6282f..8145763b98 100644
--- a/src/openrct2/rct12/RCT12.h
+++ b/src/openrct2/rct12/RCT12.h
@@ -67,6 +67,17 @@ enum class RCT12TrackDesignVersion : uint8_t
     unknown
 };
 
+enum
+{
+    RCT12_TILE_ELEMENT_FLAG_GHOST = (1 << 4),
+    RCT12_TILE_ELEMENT_FLAG_BROKEN = (1 << 5),
+    RCT12_TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED = (1 << 5),
+    RCT12_TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE = (1 << 6),
+    RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE = (1 << 6),
+    RCT12_TILE_ELEMENT_FLAG_LARGE_SCENERY_ACCOUNTED = (1 << 6),
+    RCT12_TILE_ELEMENT_FLAG_LAST_TILE = (1 << 7)
+};
+
 enum
 {
     RCT12_TRACK_ELEMENT_TYPE_FLAG_CHAIN_LIFT = 1 << 7,
@@ -242,9 +253,15 @@ struct RCT12TileElementBase
     uint8_t clearance_height; // 3
     uint8_t GetType() const;
     uint8_t GetDirection() const;
-    bool IsLastForTile() const;
-    bool IsGhost() const;
     void SetDirection(uint8_t direction);
+
+    uint8_t GetOccupiedQuadrants() const;
+    void SetOccupiedQuadrants(uint8_t quadrants);
+
+    bool IsLastForTile() const;
+    void SetLastForTile(bool on);
+    bool IsGhost() const;
+    void SetGhost(bool isGhost);
 };
 /**
  * Map element structure
@@ -365,6 +382,12 @@ public:
     void SetAddition(uint8_t newAddition);
     void SetAdditionIsGhost(bool isGhost);
     void SetAdditionStatus(uint8_t newStatus);
+
+    bool IsBroken() const;
+    void SetIsBroken(bool isBroken);
+
+    bool IsBlockedByVehicle() const;
+    void SetIsBlockedByVehicle(bool isBlocked);
 };
 assert_struct_size(RCT12PathElement, 8);
 struct RCT12TrackElement : RCT12TileElementBase
@@ -419,12 +442,16 @@ public:
     void SetHasChain(bool on);
     void SetHasCableLift(bool on);
     void SetInverted(bool inverted);
+    bool BlockBrakeClosed() const;
     void SetBlockBrakeClosed(bool isClosed);
     void SetBrakeBoosterSpeed(uint8_t speed);
     void SetHasGreenLight(uint8_t greenLight);
     void SetSeatRotation(uint8_t newSeatRotation);
     void SetMazeEntry(uint16_t newMazeEntry);
     void SetPhotoTimeout(uint8_t newValue);
+
+    bool IsIndestructible() const;
+    void SetIsIndestructible(bool isIndestructible);
 };
 assert_struct_size(RCT12TrackElement, 8);
 struct RCT12SmallSceneryElement : RCT12TileElementBase
diff --git a/src/openrct2/rct2/S6Exporter.cpp b/src/openrct2/rct2/S6Exporter.cpp
index 4e5055b2bc..a4ca6371d0 100644
--- a/src/openrct2/rct2/S6Exporter.cpp
+++ b/src/openrct2/rct2/S6Exporter.cpp
@@ -1423,10 +1423,14 @@ void S6Exporter::ExportTileElement(RCT12TileElement* dst, TileElement* src)
     uint8_t tileElementType = src->GetType();
     dst->ClearAs(tileElementType);
     dst->SetDirection(src->GetDirection());
-    dst->flags = src->flags;
     dst->base_height = src->base_height;
     dst->clearance_height = src->clearance_height;
 
+    // All saved in "flags"
+    dst->SetOccupiedQuadrants(src->GetOccupiedQuadrants());
+    dst->SetGhost(src->IsGhost());
+    dst->SetLastForTile(src->IsLastForTile());
+
     switch (tileElementType)
     {
         case TILE_ELEMENT_TYPE_SURFACE:
@@ -1464,6 +1468,8 @@ void S6Exporter::ExportTileElement(RCT12TileElement* dst, TileElement* src)
             dst2->SetAddition(src2->GetAddition());
             dst2->SetAdditionIsGhost(src2->AdditionIsGhost());
             dst2->SetAdditionStatus(src2->GetAdditionStatus());
+            dst2->SetIsBroken(src2->IsBroken());
+            dst2->SetIsBlockedByVehicle(src2->IsBlockedByVehicle());
 
             break;
         }
@@ -1483,6 +1489,8 @@ void S6Exporter::ExportTileElement(RCT12TileElement* dst, TileElement* src)
             dst2->SetInverted(src2->IsInverted());
             dst2->SetBrakeBoosterSpeed(src2->GetBrakeBoosterSpeed());
             dst2->SetPhotoTimeout(src2->GetPhotoTimeout());
+            dst2->SetBlockBrakeClosed(src2->BlockBrakeClosed());
+            dst2->SetIsIndestructible(src2->IsIndestructible());
 
             auto ride = get_ride(dst2->GetRideIndex());
             if (ride)
diff --git a/src/openrct2/rct2/S6Importer.cpp b/src/openrct2/rct2/S6Importer.cpp
index 398ea5ac16..00b72eb4b4 100644
--- a/src/openrct2/rct2/S6Importer.cpp
+++ b/src/openrct2/rct2/S6Importer.cpp
@@ -1025,10 +1025,14 @@ public:
         uint8_t tileElementType = src->GetType();
         dst->ClearAs(tileElementType);
         dst->SetDirection(src->GetDirection());
-        dst->flags = src->flags;
         dst->base_height = src->base_height;
         dst->clearance_height = src->clearance_height;
 
+        // All saved in "flags"
+        dst->SetOccupiedQuadrants(src->GetOccupiedQuadrants());
+        dst->SetGhost(src->IsGhost());
+        dst->SetLastForTile(src->IsLastForTile());
+
         switch (tileElementType)
         {
             case TILE_ELEMENT_TYPE_SURFACE:
@@ -1066,6 +1070,8 @@ public:
                 dst2->SetAddition(src2->GetAddition());
                 dst2->SetAdditionIsGhost(src2->AdditionIsGhost());
                 dst2->SetAdditionStatus(src2->GetAdditionStatus());
+                dst2->SetIsBroken(src2->IsBroken());
+                dst2->SetIsBlockedByVehicle(src2->IsBlockedByVehicle());
 
                 break;
             }
@@ -1083,6 +1089,8 @@ public:
                 dst2->SetInverted(src2->IsInverted());
                 dst2->SetStationIndex(src2->GetStationIndex());
                 dst2->SetHasGreenLight(src2->HasGreenLight());
+                dst2->SetBlockBrakeClosed(src2->BlockBrakeClosed());
+                dst2->SetIsIndestructible(src2->IsIndestructible());
 
                 auto trackType = dst2->GetTrackType();
                 if (track_element_has_speed_setting(trackType))
diff --git a/src/openrct2/ride/Track.cpp b/src/openrct2/ride/Track.cpp
index c1389947c8..b58c00150c 100644
--- a/src/openrct2/ride/Track.cpp
+++ b/src/openrct2/ride/Track.cpp
@@ -1377,35 +1377,35 @@ void TrackElement::SetInverted(bool inverted)
 
 bool TrackElement::BlockBrakeClosed() const
 {
-    return (flags & TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED) != 0;
+    return (Flags2 & TRACK_ELEMENT_FLAG2_BLOCK_BRAKE_CLOSED) != 0;
 }
 
 void TrackElement::SetBlockBrakeClosed(bool isClosed)
 {
     if (isClosed)
     {
-        flags |= TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
+        Flags2 |= TRACK_ELEMENT_FLAG2_BLOCK_BRAKE_CLOSED;
     }
     else
     {
-        flags &= ~TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED;
+        Flags2 &= ~TRACK_ELEMENT_FLAG2_BLOCK_BRAKE_CLOSED;
     }
 }
 
 bool TrackElement::IsIndestructible() const
 {
-    return (flags & TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE) != 0;
+    return (Flags2 & TRACK_ELEMENT_FLAG2_INDESTRUCTIBLE_TRACK_PIECE) != 0;
 }
 
 void TrackElement::SetIsIndestructible(bool isIndestructible)
 {
     if (isIndestructible)
     {
-        flags |= TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE;
+        Flags2 |= TRACK_ELEMENT_FLAG2_INDESTRUCTIBLE_TRACK_PIECE;
     }
     else
     {
-        flags &= ~TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE;
+        Flags2 &= ~TRACK_ELEMENT_FLAG2_INDESTRUCTIBLE_TRACK_PIECE;
     }
 }
 
diff --git a/src/openrct2/ride/Track.h b/src/openrct2/ride/Track.h
index 56688274b6..07f2bb95fd 100644
--- a/src/openrct2/ride/Track.h
+++ b/src/openrct2/ride/Track.h
@@ -66,6 +66,8 @@ enum
     TRACK_ELEMENT_FLAGS2_CABLE_LIFT = 1 << 2,
     TRACK_ELEMENT_FLAGS2_HIGHLIGHT = 1 << 3,
     TRACK_ELEMENT_FLAGS2_HAS_GREEN_LIGHT = 1 << 4,
+    TRACK_ELEMENT_FLAG2_BLOCK_BRAKE_CLOSED = 1 << 5,
+    TRACK_ELEMENT_FLAG2_INDESTRUCTIBLE_TRACK_PIECE = 1 << 6,
 };
 
 enum
diff --git a/src/openrct2/world/Footpath.cpp b/src/openrct2/world/Footpath.cpp
index 2d7f22f32a..61af8437bf 100644
--- a/src/openrct2/world/Footpath.cpp
+++ b/src/openrct2/world/Footpath.cpp
@@ -1470,35 +1470,35 @@ void PathElement::SetHasQueueBanner(bool hasQueueBanner)
 
 bool PathElement::IsBroken() const
 {
-    return (flags & TILE_ELEMENT_FLAG_BROKEN) != 0;
+    return (Flags2 & FOOTPATH_ELEMENT_FLAGS2_ADDITION_IS_BROKEN) != 0;
 }
 
 void PathElement::SetIsBroken(bool isBroken)
 {
     if (isBroken)
     {
-        flags |= TILE_ELEMENT_FLAG_BROKEN;
+        Flags2 |= FOOTPATH_ELEMENT_FLAGS2_ADDITION_IS_BROKEN;
     }
     else
     {
-        flags &= ~TILE_ELEMENT_FLAG_BROKEN;
+        Flags2 &= ~FOOTPATH_ELEMENT_FLAGS2_ADDITION_IS_BROKEN;
     }
 }
 
 bool PathElement::IsBlockedByVehicle() const
 {
-    return (flags & TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE) != 0;
+    return (Flags2 & FOOTPATH_ELEMENT_FLAGS2_BLOCKED_BY_VEHICLE) != 0;
 }
 
 void PathElement::SetIsBlockedByVehicle(bool isBlocked)
 {
     if (isBlocked)
     {
-        flags |= TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE;
+        Flags2 |= FOOTPATH_ELEMENT_FLAGS2_BLOCKED_BY_VEHICLE;
     }
     else
     {
-        flags &= ~TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE;
+        Flags2 &= ~FOOTPATH_ELEMENT_FLAGS2_BLOCKED_BY_VEHICLE;
     }
 }
 
diff --git a/src/openrct2/world/Footpath.h b/src/openrct2/world/Footpath.h
index 1f7178f43c..21e100de9d 100644
--- a/src/openrct2/world/Footpath.h
+++ b/src/openrct2/world/Footpath.h
@@ -101,6 +101,8 @@ enum
     FOOTPATH_ELEMENT_FLAGS2_IS_SLOPED = 1 << 0,
     FOOTPATH_ELEMENT_FLAGS2_HAS_QUEUE_BANNER = (1 << 1),
     FOOTPATH_ELEMENT_FLAGS2_ADDITION_IS_GHOST = (1 << 2),
+    FOOTPATH_ELEMENT_FLAGS2_BLOCKED_BY_VEHICLE = (1 << 3),
+    FOOTPATH_ELEMENT_FLAGS2_ADDITION_IS_BROKEN = (1 << 4),
 };
 
 enum
diff --git a/src/openrct2/world/LargeScenery.cpp b/src/openrct2/world/LargeScenery.cpp
index ba06b4651f..741b1f666c 100644
--- a/src/openrct2/world/LargeScenery.cpp
+++ b/src/openrct2/world/LargeScenery.cpp
@@ -54,18 +54,18 @@ void LargeSceneryElement::SetBannerIndex(::BannerIndex newIndex)
 
 bool LargeSceneryElement::IsAccounted() const
 {
-    return (flags & TILE_ELEMENT_FLAG_LARGE_SCENERY_ACCOUNTED) != 0;
+    return (Flags2 & LARGE_SCENERY_ELEMENT_FLAGS2_ACCOUNTED) != 0;
 }
 
 void LargeSceneryElement::SetIsAccounted(bool isAccounted)
 {
     if (isAccounted)
     {
-        flags |= TILE_ELEMENT_FLAG_LARGE_SCENERY_ACCOUNTED;
+        Flags2 |= LARGE_SCENERY_ELEMENT_FLAGS2_ACCOUNTED;
     }
     else
     {
-        flags &= ~TILE_ELEMENT_FLAG_LARGE_SCENERY_ACCOUNTED;
+        Flags2 &= ~LARGE_SCENERY_ELEMENT_FLAGS2_ACCOUNTED;
     }
 }
 
diff --git a/src/openrct2/world/LargeScenery.h b/src/openrct2/world/LargeScenery.h
index 070a68e968..c0490bcb77 100644
--- a/src/openrct2/world/LargeScenery.h
+++ b/src/openrct2/world/LargeScenery.h
@@ -14,3 +14,8 @@
 #include "TileElement.h"
 
 rct_scenery_entry* get_large_scenery_entry(int32_t entryIndex);
+
+enum 
+{
+    LARGE_SCENERY_ELEMENT_FLAGS2_ACCOUNTED = 1 << 0,
+};
diff --git a/src/openrct2/world/Map.cpp b/src/openrct2/world/Map.cpp
index 4374aee813..126b927463 100644
--- a/src/openrct2/world/Map.cpp
+++ b/src/openrct2/world/Map.cpp
@@ -1174,7 +1174,7 @@ TileElement* tile_element_insert(const TileCoordsXYZ& loc, int32_t occupiedQuadr
     insertedElement = newTileElement;
     newTileElement->type = 0;
     newTileElement->base_height = loc.z;
-    newTileElement->flags = 0;
+    newTileElement->Flags = 0;
     newTileElement->SetLastForTile(isLastForTile);
     newTileElement->SetOccupiedQuadrants(occupiedQuadrants);
     newTileElement->clearance_height = loc.z;
diff --git a/src/openrct2/world/TileElement.cpp b/src/openrct2/world/TileElement.cpp
index db1cc26f37..1cbd092154 100644
--- a/src/openrct2/world/TileElement.cpp
+++ b/src/openrct2/world/TileElement.cpp
@@ -46,31 +46,31 @@ Direction TileElementBase::GetDirectionWithOffset(uint8_t offset) const
 
 bool TileElementBase::IsLastForTile() const
 {
-    return (this->flags & TILE_ELEMENT_FLAG_LAST_TILE) != 0;
+    return (this->Flags & TILE_ELEMENT_FLAG_LAST_TILE) != 0;
 }
 
 void TileElementBase::SetLastForTile(bool on)
 {
     if (on)
-        flags |= TILE_ELEMENT_FLAG_LAST_TILE;
+        Flags |= TILE_ELEMENT_FLAG_LAST_TILE;
     else
-        flags &= ~TILE_ELEMENT_FLAG_LAST_TILE;
+        Flags &= ~TILE_ELEMENT_FLAG_LAST_TILE;
 }
 
 bool TileElementBase::IsGhost() const
 {
-    return (this->flags & TILE_ELEMENT_FLAG_GHOST) != 0;
+    return (this->Flags & TILE_ELEMENT_FLAG_GHOST) != 0;
 }
 
 void TileElementBase::SetGhost(bool isGhost)
 {
     if (isGhost)
     {
-        this->flags |= TILE_ELEMENT_FLAG_GHOST;
+        this->Flags |= TILE_ELEMENT_FLAG_GHOST;
     }
     else
     {
-        this->flags &= ~TILE_ELEMENT_FLAG_GHOST;
+        this->Flags &= ~TILE_ELEMENT_FLAG_GHOST;
     }
 }
 
@@ -158,7 +158,7 @@ uint8_t tile_element_get_ride_index(const TileElement* tileElement)
 void TileElement::ClearAs(uint8_t newType)
 {
     type = newType;
-    flags = 0;
+    Flags = 0;
     base_height = 2;
     clearance_height = 2;
     std::fill_n(pad_04, sizeof(pad_04), 0x00);
@@ -216,13 +216,13 @@ const QuarterTile QuarterTile::Rotate(uint8_t amount) const
 
 uint8_t TileElementBase::GetOccupiedQuadrants() const
 {
-    return flags & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK;
+    return Flags & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK;
 }
 
 void TileElementBase::SetOccupiedQuadrants(uint8_t quadrants)
 {
-    flags &= ~TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK;
-    flags |= (quadrants & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK);
+    Flags &= ~TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK;
+    Flags |= (quadrants & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK);
 }
 
 int32_t TileElementBase::GetBaseZ() const
diff --git a/src/openrct2/world/TileElement.h b/src/openrct2/world/TileElement.h
index 27045e3094..cd8ffa77d5 100644
--- a/src/openrct2/world/TileElement.h
+++ b/src/openrct2/world/TileElement.h
@@ -64,24 +64,30 @@ struct CorruptElement;
 struct TileElementBase
 {
     uint8_t type;             // 0
-    uint8_t flags;            // 1. Upper nibble: flags. Lower nibble: occupied quadrants (one bit per quadrant).
+    uint8_t Flags;            // 1. Upper nibble: flags. Lower nibble: occupied quadrants (one bit per quadrant).
     uint8_t base_height;      // 2
     uint8_t clearance_height; // 3
 
+    void Remove();
+
     uint8_t GetType() const;
     void SetType(uint8_t newType);
+
     Direction GetDirection() const;
     void SetDirection(Direction direction);
     Direction GetDirectionWithOffset(uint8_t offset) const;
+
     bool IsLastForTile() const;
     void SetLastForTile(bool on);
     bool IsGhost() const;
     void SetGhost(bool isGhost);
-    void Remove();
+
     uint8_t GetOccupiedQuadrants() const;
     void SetOccupiedQuadrants(uint8_t quadrants);
+
     int32_t GetBaseZ() const;
     void SetBaseZ(int32_t newZ);
+
     int32_t GetClearanceZ() const;
     void SetClearanceZ(int32_t newZ);
 };
@@ -149,7 +155,7 @@ private:
     uint8_t EdgeStyle;
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-private-field"
-    uint8_t pad_08[6];
+    uint8_t pad_0A[6];
 #pragma clang diagnostic pop
 
 public:
@@ -399,9 +405,10 @@ private:
     ::BannerIndex BannerIndex;
     uint8_t SequenceIndex;
     uint8_t Colour[3];
+    uint8_t Flags2;
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-private-field"
-    uint8_t pad[4];
+    uint8_t pad[3];
 #pragma clang diagnostic pop
 
 public:
@@ -593,11 +600,6 @@ enum
 enum
 {
     TILE_ELEMENT_FLAG_GHOST = (1 << 4),
-    TILE_ELEMENT_FLAG_BROKEN = (1 << 5),
-    TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED = (1 << 5),
-    TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE = (1 << 6),
-    TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE = (1 << 6),
-    TILE_ELEMENT_FLAG_LARGE_SCENERY_ACCOUNTED = (1 << 6),
     TILE_ELEMENT_FLAG_LAST_TILE = (1 << 7)
 };