diff --git a/src/openrct2/GameStateSnapshots.cpp b/src/openrct2/GameStateSnapshots.cpp
index 95a758cddd..c801c52edc 100644
--- a/src/openrct2/GameStateSnapshots.cpp
+++ b/src/openrct2/GameStateSnapshots.cpp
@@ -35,7 +35,7 @@ union EntitySnapshot
     {
     }
 };
-assert_struct_size(EntitySnapshot, 0x200);
+static_assert(sizeof(EntitySnapshot) == 0x200);
 #pragma pack(pop)
 
 struct GameStateSnapshot_t
diff --git a/src/openrct2/common.h b/src/openrct2/common.h
index b8f3e5a35e..ec843f1713 100644
--- a/src/openrct2/common.h
+++ b/src/openrct2/common.h
@@ -31,5 +31,3 @@
 using datetime64 = uint64_t;
 
 constexpr datetime64 DATETIME64_MIN = 0;
-
-#define assert_struct_size(x, y) static_assert(sizeof(x) == (y), "Improper struct size")
diff --git a/src/openrct2/drawing/Drawing.h b/src/openrct2/drawing/Drawing.h
index 6737aeeb9c..4c502e57c2 100644
--- a/src/openrct2/drawing/Drawing.h
+++ b/src/openrct2/drawing/Drawing.h
@@ -94,7 +94,7 @@ struct RCTG1Header
     uint32_t num_entries = 0;
     uint32_t total_size = 0;
 };
-assert_struct_size(RCTG1Header, 8);
+static_assert(sizeof(RCTG1Header) == 8);
 #pragma pack(pop)
 
 struct Gx
@@ -168,7 +168,7 @@ struct RCTG1Element
     uint16_t flags;         // 0x0C
     uint16_t zoomed_offset; // 0x0E
 };
-assert_struct_size(RCTG1Element, 0x10);
+static_assert(sizeof(RCTG1Element) == 0x10);
 
 enum
 {
diff --git a/src/openrct2/object/Object.h b/src/openrct2/object/Object.h
index d4c8cefe76..33121caea8 100644
--- a/src/openrct2/object/Object.h
+++ b/src/openrct2/object/Object.h
@@ -101,7 +101,7 @@ struct RCTObjectEntry
     bool operator==(const RCTObjectEntry& rhs) const;
     bool operator!=(const RCTObjectEntry& rhs) const;
 };
-assert_struct_size(RCTObjectEntry, 0x10);
+static_assert(sizeof(RCTObjectEntry) == 0x10);
 
 #pragma pack(pop)
 
diff --git a/src/openrct2/rct1/RCT1.h b/src/openrct2/rct1/RCT1.h
index 3f1270b3d5..4979de0695 100644
--- a/src/openrct2/rct1/RCT1.h
+++ b/src/openrct2/rct1/RCT1.h
@@ -231,7 +231,7 @@ namespace RCT1
         uint16_t z;
         uint8_t direction;
     };
-    assert_struct_size(Entrance, 7);
+    static_assert(sizeof(Entrance) == 7);
 
     /**
      * RCT1 ride structure
@@ -387,7 +387,7 @@ namespace RCT1
         uint8_t EntranceStyle;                          // 0x179
         uint8_t Unk17A[230];                            // 0x17A
     };
-    assert_struct_size(Ride, 0x260);
+    static_assert(sizeof(Ride) == 0x260);
 
     struct UnkEntity : RCT12EntityBase
     {
@@ -684,7 +684,7 @@ namespace RCT1
             return ItemStandardFlags;
         }
     };
-    assert_struct_size(Peep, 0x100);
+    static_assert(sizeof(Peep) == 0x100);
 
     union Entity
     {
@@ -701,7 +701,7 @@ namespace RCT1
         RCT12EntityCrashSplash CrashSplash;
         RCT12EntitySteamParticle SteamParticle;
     };
-    assert_struct_size(Entity, 0x100);
+    static_assert(sizeof(Entity) == 0x100);
 
     struct ResearchItem
     {
@@ -711,7 +711,7 @@ namespace RCT1
         uint8_t Flags;
         uint8_t Category;
     };
-    assert_struct_size(ResearchItem, 5);
+    static_assert(sizeof(ResearchItem) == 5);
 
     /**
      * RCT1,AA,LL scenario / saved game structure.
@@ -888,7 +888,7 @@ namespace RCT1
         uint8_t Unk1F8358[432];
         uint32_t ExpansionPackChecksum;
     };
-    assert_struct_size(S4, 0x1F850C);
+    static_assert(sizeof(S4) == 0x1F850C);
 
     /**
      * Track design structure. Only for base RCT1
@@ -936,7 +936,7 @@ namespace RCT1
         money16 UpkeepCost;        // 0x36
     };
 
-    assert_struct_size(TD4, 0x38);
+    static_assert(sizeof(TD4) == 0x38);
 
     /**
      * Track design structure for Added Attractions / Loopy Landscapes
@@ -952,7 +952,7 @@ namespace RCT1
         uint8_t Pad45[0x7F]; // 0x45
     };
 
-    assert_struct_size(TD4AA, 0xC4);
+    static_assert(sizeof(TD4AA) == 0xC4);
 #pragma pack(pop)
 
     enum
diff --git a/src/openrct2/rct12/RCT12.h b/src/openrct2/rct12/RCT12.h
index e6915d9497..9dd96900b5 100644
--- a/src/openrct2/rct12/RCT12.h
+++ b/src/openrct2/rct12/RCT12.h
@@ -219,7 +219,7 @@ struct RCT12xy8
         xy = RCT12_XY8_UNDEFINED;
     }
 };
-assert_struct_size(RCT12xy8, 2);
+static_assert(sizeof(RCT12xy8) == 2);
 
 enum class TD46MazeElementType : uint8_t
 {
@@ -259,7 +259,7 @@ struct TD46MazeElement
         return Type == EnumValue(TD46MazeElementType::Exit);
     }
 };
-assert_struct_size(TD46MazeElement, 0x04);
+static_assert(sizeof(TD46MazeElement) == 0x04);
 
 /* Track Element entry  size: 0x02 */
 struct TD46TrackElement
@@ -267,14 +267,14 @@ struct TD46TrackElement
     uint8_t Type;  // 0x00
     uint8_t Flags; // 0x01
 };
-assert_struct_size(TD46TrackElement, 0x02);
+static_assert(sizeof(TD46TrackElement) == 0x02);
 
 struct RCT12Award
 {
     uint16_t Time;
     uint16_t Type;
 };
-assert_struct_size(RCT12Award, 4);
+static_assert(sizeof(RCT12Award) == 4);
 
 /**
  * A single news item / message.
@@ -291,13 +291,13 @@ struct RCT12NewsItem
     uint8_t Pad0B;
     char Text[256];
 };
-assert_struct_size(RCT12NewsItem, 0x10C);
+static_assert(sizeof(RCT12NewsItem) == 0x10C);
 
 struct RCT12xyzd8
 {
     uint8_t x, y, z, direction;
 };
-assert_struct_size(RCT12xyzd8, 4);
+static_assert(sizeof(RCT12xyzd8) == 4);
 
 struct RCT12PeepSpawn
 {
@@ -306,7 +306,7 @@ struct RCT12PeepSpawn
     uint8_t z;
     uint8_t direction;
 };
-assert_struct_size(RCT12PeepSpawn, 6);
+static_assert(sizeof(RCT12PeepSpawn) == 6);
 
 enum class RCT12TileElementType : uint8_t
 {
@@ -451,7 +451,7 @@ struct RCT12TileElement : public RCT12TileElementBase
         return as<RCT12BannerElement, RCT12TileElementType::Banner>();
     }
 };
-assert_struct_size(RCT12TileElement, 8);
+static_assert(sizeof(RCT12TileElement) == 8);
 struct RCT12SurfaceElement : RCT12TileElementBase
 {
 private:
@@ -469,7 +469,7 @@ public:
     uint8_t GetParkFences() const;
     bool HasTrackThatNeedsWater() const;
 };
-assert_struct_size(RCT12SurfaceElement, 8);
+static_assert(sizeof(RCT12SurfaceElement) == 8);
 struct RCT12PathElement : RCT12TileElementBase
 {
 private:
@@ -504,7 +504,7 @@ public:
 
     bool IsBlockedByVehicle() const;
 };
-assert_struct_size(RCT12PathElement, 8);
+static_assert(sizeof(RCT12PathElement) == 8);
 struct RCT12TrackElement : RCT12TileElementBase
 {
 private:
@@ -551,7 +551,7 @@ public:
     bool BlockBrakeClosed() const;
     bool IsIndestructible() const;
 };
-assert_struct_size(RCT12TrackElement, 8);
+static_assert(sizeof(RCT12TrackElement) == 8);
 struct RCT12SmallSceneryElement : RCT12TileElementBase
 {
 private:
@@ -567,7 +567,7 @@ public:
     colour_t GetSecondaryColour() const;
     bool NeedsSupports() const;
 };
-assert_struct_size(RCT12SmallSceneryElement, 8);
+static_assert(sizeof(RCT12SmallSceneryElement) == 8);
 struct RCT12LargeSceneryElement : RCT12TileElementBase
 {
 private:
@@ -580,7 +580,7 @@ public:
     colour_t GetSecondaryColour() const;
     uint8_t GetBannerIndex() const;
 };
-assert_struct_size(RCT12LargeSceneryElement, 8);
+static_assert(sizeof(RCT12LargeSceneryElement) == 8);
 struct RCT12WallElement : RCT12TileElementBase
 {
 private:
@@ -606,7 +606,7 @@ public:
     colour_t GetRCT1WallColour() const;
     uint8_t GetRCT1Slope() const;
 };
-assert_struct_size(RCT12WallElement, 8);
+static_assert(sizeof(RCT12WallElement) == 8);
 struct RCT12EntranceElement : RCT12TileElementBase
 {
 private:
@@ -621,7 +621,7 @@ public:
     uint8_t GetSequenceIndex() const;
     uint8_t GetPathType() const;
 };
-assert_struct_size(RCT12EntranceElement, 8);
+static_assert(sizeof(RCT12EntranceElement) == 8);
 struct RCT12BannerElement : RCT12TileElementBase
 {
 private:
@@ -637,25 +637,25 @@ public:
     uint8_t GetPosition() const;
     uint8_t GetAllowedEdges() const;
 };
-assert_struct_size(RCT12BannerElement, 8);
+static_assert(sizeof(RCT12BannerElement) == 8);
 
 struct RCT12CorruptElement : RCT12TileElementBase
 {
     uint8_t Pad[4];
 };
-assert_struct_size(RCT12CorruptElement, 8);
+static_assert(sizeof(RCT12CorruptElement) == 8);
 
 struct RCT12EightCarsCorruptElement14 : RCT12TileElementBase
 {
     uint8_t Pad[4];
 };
-assert_struct_size(RCT12EightCarsCorruptElement14, 8);
+static_assert(sizeof(RCT12EightCarsCorruptElement14) == 8);
 
 struct RCT12EightCarsCorruptElement15 : RCT12TileElementBase
 {
     uint8_t Pad[4];
 };
-assert_struct_size(RCT12EightCarsCorruptElement15, 8);
+static_assert(sizeof(RCT12EightCarsCorruptElement15) == 8);
 
 // Offset into EntityListHead and EntityListCount
 enum class RCT12EntityLinkListOffset : uint8_t
@@ -721,7 +721,7 @@ struct RCT12EntityBase
     int16_t SpriteBottom;                           // 0x1C
     uint8_t EntityDirection;                        // 0x1E
 };
-assert_struct_size(RCT12EntityBase, 0x1F);
+static_assert(sizeof(RCT12EntityBase) == 0x1F);
 
 struct RCT12EntityBalloon : RCT12EntityBase
 {
@@ -732,7 +732,7 @@ struct RCT12EntityBalloon : RCT12EntityBase
     uint8_t Pad28[4];
     uint8_t Colour; // 0x2C
 };
-assert_struct_size(RCT12EntityBalloon, 0x2D);
+static_assert(sizeof(RCT12EntityBalloon) == 0x2D);
 
 struct RCT12EntityDuck : RCT12EntityBase
 {
@@ -744,21 +744,21 @@ struct RCT12EntityDuck : RCT12EntityBase
     uint8_t Pad34[0x14];
     uint8_t State; // 0x48
 };
-assert_struct_size(RCT12EntityDuck, 0x49);
+static_assert(sizeof(RCT12EntityDuck) == 0x49);
 
 struct RCT12EntityLitter : RCT12EntityBase
 {
     uint8_t Pad1F[0x24 - 0x1F];
     uint32_t CreationTick; // 0x24
 };
-assert_struct_size(RCT12EntityLitter, 0x28);
+static_assert(sizeof(RCT12EntityLitter) == 0x28);
 
 struct RCT12EntityParticle : RCT12EntityBase
 {
     uint8_t Pad1F[0x26 - 0x1F];
     uint16_t Frame; // 0x26
 };
-assert_struct_size(RCT12EntityParticle, 0x28);
+static_assert(sizeof(RCT12EntityParticle) == 0x28);
 
 struct RCT12EntityJumpingFountain : RCT12EntityBase
 {
@@ -772,7 +772,7 @@ struct RCT12EntityJumpingFountain : RCT12EntityBase
     uint8_t Pad34[0x46 - 0x34];
     uint16_t Iteration; // 0x46
 };
-assert_struct_size(RCT12EntityJumpingFountain, 0x48);
+static_assert(sizeof(RCT12EntityJumpingFountain) == 0x48);
 
 struct RCT12EntityMoneyEffect : RCT12EntityBase
 {
@@ -785,7 +785,7 @@ struct RCT12EntityMoneyEffect : RCT12EntityBase
     int16_t OffsetX; // 0x44
     uint16_t Wiggle; // 0x46
 };
-assert_struct_size(RCT12EntityMoneyEffect, 0x48);
+static_assert(sizeof(RCT12EntityMoneyEffect) == 0x48);
 
 struct RCT12EntityCrashedVehicleParticle : RCT12EntityBase
 {
@@ -803,14 +803,14 @@ struct RCT12EntityCrashedVehicleParticle : RCT12EntityBase
     int32_t AccelerationY; // 0x3C
     int32_t AccelerationZ; // 0x40
 };
-assert_struct_size(RCT12EntityCrashedVehicleParticle, 0x44);
+static_assert(sizeof(RCT12EntityCrashedVehicleParticle) == 0x44);
 
 struct RCT12EntityCrashSplash : RCT12EntityBase
 {
     uint8_t Pad1F[0x26 - 0x1F];
     uint16_t Frame; // 0x26
 };
-assert_struct_size(RCT12EntityCrashSplash, 0x28);
+static_assert(sizeof(RCT12EntityCrashSplash) == 0x28);
 
 struct RCT12EntitySteamParticle : RCT12EntityBase
 {
@@ -818,7 +818,7 @@ struct RCT12EntitySteamParticle : RCT12EntityBase
     uint16_t TimeToMove; // 0x24
     uint16_t Frame;      // 0x26
 };
-assert_struct_size(RCT12EntitySteamParticle, 0x28);
+static_assert(sizeof(RCT12EntitySteamParticle) == 0x28);
 
 struct RCT12PeepThought
 {
@@ -827,7 +827,7 @@ struct RCT12PeepThought
     uint8_t Freshness;
     uint8_t FreshTimeout;
 };
-assert_struct_size(RCT12PeepThought, 4);
+static_assert(sizeof(RCT12PeepThought) == 4);
 
 struct RCT12RideMeasurement
 {
@@ -843,7 +843,7 @@ struct RCT12RideMeasurement
     uint8_t Velocity[RCT12::Limits::RideMeasurementMaxItems]; // 0x258C
     uint8_t Altitude[RCT12::Limits::RideMeasurementMaxItems]; // 0x384C
 };
-assert_struct_size(RCT12RideMeasurement, 0x4B0C);
+static_assert(sizeof(RCT12RideMeasurement) == 0x4B0C);
 
 struct RCT12Banner
 {
@@ -859,7 +859,7 @@ struct RCT12Banner
     uint8_t x;          // 0x06
     uint8_t y;          // 0x07
 };
-assert_struct_size(RCT12Banner, 8);
+static_assert(sizeof(RCT12Banner) == 8);
 
 struct RCT12MapAnimation
 {
@@ -868,7 +868,7 @@ struct RCT12MapAnimation
     uint16_t x;
     uint16_t y;
 };
-assert_struct_size(RCT12MapAnimation, 6);
+static_assert(sizeof(RCT12MapAnimation) == 6);
 
 struct RCT12ResearchItem
 {
@@ -892,14 +892,14 @@ struct RCT12ResearchItem
 
     ResearchItem ToResearchItem() const;
 };
-assert_struct_size(RCT12ResearchItem, 5);
+static_assert(sizeof(RCT12ResearchItem) == 5);
 
 struct RCT12VehicleColour
 {
     uint8_t BodyColour;
     uint8_t TrimColour;
 };
-assert_struct_size(RCT12VehicleColour, 2);
+static_assert(sizeof(RCT12VehicleColour) == 2);
 
 #pragma pack(pop)
 
diff --git a/src/openrct2/rct2/RCT2.h b/src/openrct2/rct2/RCT2.h
index 14e7eb1323..0c1a0c7bcc 100644
--- a/src/openrct2/rct2/RCT2.h
+++ b/src/openrct2/rct2/RCT2.h
@@ -283,7 +283,7 @@ namespace RCT2
         void SetMinCarsPerTrain(uint8_t newValue);
         void SetMaxCarsPerTrain(uint8_t newValue);
     };
-    assert_struct_size(Ride, 0x260);
+    static_assert(sizeof(Ride) == 0x260);
 
     /* Track Entrance entry size: 0x06 */
     struct TD6EntranceElement
@@ -303,7 +303,7 @@ namespace RCT2
             return !!(direction >> 7);
         }
     };
-    assert_struct_size(TD6EntranceElement, 0x06);
+    static_assert(sizeof(TD6EntranceElement) == 0x06);
 
     /* Track Scenery entry  size: 0x16 */
     struct TD6SceneryElement
@@ -319,7 +319,7 @@ namespace RCT2
         colour_t getTertiaryWallColour() const;
         void setTertiaryWallColour(colour_t colour);
     };
-    assert_struct_size(TD6SceneryElement, 0x16);
+    static_assert(sizeof(TD6SceneryElement) == 0x16);
 
     /**
      * Track design structure.
@@ -370,7 +370,7 @@ namespace RCT2
         uint8_t LiftHillSpeedNumCircuits;                           // 0xA2 0bCCCL_LLLL
         // 0xA3 (data starts here in file)
     };
-    assert_struct_size(TD6Track, 0xA3);
+    static_assert(sizeof(TD6Track) == 0xA3);
 
     /**
      * scores.dat file header.
@@ -383,7 +383,7 @@ namespace RCT2
         uint32_t Var8;
         uint32_t ScenarioCount;
     };
-    assert_struct_size(ScoresHeader, 0x10);
+    static_assert(sizeof(ScoresHeader) == 0x10);
 
     /**
      * An entry of scores.dat
@@ -404,7 +404,7 @@ namespace RCT2
         money32 CompanyValue;
         char CompletedBy[64];
     };
-    assert_struct_size(ScoresEntry, 0x02B0);
+    static_assert(sizeof(ScoresEntry) == 0x02B0);
 
     struct Vehicle : RCT12EntityBase
     {
@@ -529,7 +529,7 @@ namespace RCT2
             TrackTypeAndDirection |= trackDirection & RCT12VehicleTrackDirectionMask;
         }
     };
-    assert_struct_size(Vehicle, 0xDA);
+    static_assert(sizeof(Vehicle) == 0xDA);
 
     struct Peep : RCT12EntityBase
     {
@@ -690,7 +690,7 @@ namespace RCT2
             return ItemStandardFlags | (static_cast<uint64_t>(ItemExtraFlags) << 32);
         }
     };
-    assert_struct_size(Peep, 0x100);
+    static_assert(sizeof(Peep) == 0x100);
 
     enum class StaffMode : uint8_t
     {
@@ -718,7 +718,7 @@ namespace RCT2
         RCT12EntitySteamParticle SteamParticle;
         RCT12EntityParticle MiscParticle;
     };
-    assert_struct_size(Entity, 0x100);
+    static_assert(sizeof(Entity) == 0x100);
 
     struct RideRatingCalculationData
     {
@@ -738,7 +738,7 @@ namespace RCT2
         uint16_t NumReversers;
         uint16_t StationFlags;
     };
-    assert_struct_size(RideRatingCalculationData, 76);
+    static_assert(sizeof(RideRatingCalculationData) == 76);
 
     /**
      * SV6/SC6 header chunk
@@ -753,7 +753,7 @@ namespace RCT2
         uint32_t MagicNumber;      // 0x08
         uint8_t Pad0C[0x14];
     };
-    assert_struct_size(S6Header, 0x20);
+    static_assert(sizeof(S6Header) == 0x20);
 
     /**
      * SC6 information chunk
@@ -772,7 +772,7 @@ namespace RCT2
         char Details[256];    // 0x88
         RCTObjectEntry Entry; // 0x188
     };
-    assert_struct_size(S6Info, 0x198);
+    static_assert(sizeof(S6Info) == 0x198);
 
     struct S6Data
     {
@@ -1002,7 +1002,7 @@ namespace RCT2
         uint16_t WidePathTileLoopY;
         uint8_t Pad13CE778[434];
     };
-    assert_struct_size(S6Data, 0x5a3c4a);
+    static_assert(sizeof(S6Data) == 0x5a3c4a);
 
     struct StexEntry
     {
@@ -1011,7 +1011,7 @@ namespace RCT2
         StringId Details;      // 0x04
         uint8_t Var06;
     };
-    assert_struct_size(StexEntry, 7);
+    static_assert(sizeof(StexEntry) == 7);
 #pragma pack(pop)
 
     ObjectEntryIndex RCT2RideTypeToOpenRCT2RideType(uint8_t rct2RideType, const RideObjectEntry& rideEntry);
diff --git a/src/openrct2/ride/Ride.h b/src/openrct2/ride/Ride.h
index 3eb68bb270..fed69a499d 100644
--- a/src/openrct2/ride/Ride.h
+++ b/src/openrct2/ride/Ride.h
@@ -437,7 +437,7 @@ struct TrackBeginEnd
     TileElement* end_element;
 };
 #ifdef PLATFORM_32BIT
-assert_struct_size(TrackBeginEnd, 36);
+static_assert(sizeof(TrackBeginEnd) == 36);
 #endif
 
 #pragma pack(pop)
diff --git a/src/openrct2/ride/RideRatings.h b/src/openrct2/ride/RideRatings.h
index d7894a44aa..0c50bc65bd 100644
--- a/src/openrct2/ride/RideRatings.h
+++ b/src/openrct2/ride/RideRatings.h
@@ -34,7 +34,7 @@ struct RatingTuple
     bool isNull() const;
     void setNull();
 };
-assert_struct_size(RatingTuple, 6);
+static_assert(sizeof(RatingTuple) == 6);
 
 #pragma pack(pop)
 
diff --git a/src/openrct2/util/SawyerCoding.h b/src/openrct2/util/SawyerCoding.h
index 92be12da61..adc6714b65 100644
--- a/src/openrct2/util/SawyerCoding.h
+++ b/src/openrct2/util/SawyerCoding.h
@@ -17,7 +17,7 @@ struct SawyerCodingChunkHeader
     uint8_t encoding;
     uint32_t length;
 };
-assert_struct_size(SawyerCodingChunkHeader, 5);
+static_assert(sizeof(SawyerCodingChunkHeader) == 5);
 #pragma pack(pop)
 
 enum
diff --git a/src/openrct2/util/Util.h b/src/openrct2/util/Util.h
index 1e664f1fcc..d18181625a 100644
--- a/src/openrct2/util/Util.h
+++ b/src/openrct2/util/Util.h
@@ -41,7 +41,7 @@ template<typename T> constexpr T AddClamp(T value, T valueToAdd)
 {
     if (std::is_same_v<decltype(value), money64>)
     {
-        assert_struct_size(money64, sizeof(int64_t));
+        static_assert(sizeof(money64) == sizeof(int64_t));
     }
     auto maxCap = std::numeric_limits<T>::max();
     auto minCap = std::numeric_limits<T>::lowest();
diff --git a/src/openrct2/world/Map.h b/src/openrct2/world/Map.h
index f1bc156f22..9a684bfdbc 100644
--- a/src/openrct2/world/Map.h
+++ b/src/openrct2/world/Map.h
@@ -190,7 +190,7 @@ struct TileElementIterator
     TileElement* element;
 };
 #ifdef PLATFORM_32BIT
-assert_struct_size(TileElementIterator, 12);
+static_assert(sizeof(TileElementIterator) == 12);
 #endif
 
 void TileElementIteratorBegin(TileElementIterator* it);
diff --git a/src/openrct2/world/TileElement.h b/src/openrct2/world/TileElement.h
index e90a7843f2..183253eac7 100644
--- a/src/openrct2/world/TileElement.h
+++ b/src/openrct2/world/TileElement.h
@@ -184,7 +184,7 @@ struct TileElement : public TileElementBase
     void RemoveBannerEntry();
     BannerIndex GetBannerIndex() const;
 };
-assert_struct_size(TileElement, 16);
+static_assert(sizeof(TileElement) == 16);
 
 struct SurfaceElement : TileElementBase
 {
@@ -232,7 +232,7 @@ public:
     bool HasTrackThatNeedsWater() const;
     void SetHasTrackThatNeedsWater(bool on);
 };
-assert_struct_size(SurfaceElement, 16);
+static_assert(sizeof(SurfaceElement) == 16);
 
 struct PathElement : TileElementBase
 {
@@ -326,7 +326,7 @@ public:
 
     bool IsLevelCrossing(const CoordsXY& coords) const;
 };
-assert_struct_size(PathElement, 16);
+static_assert(sizeof(PathElement) == 16);
 
 struct TrackElement : TileElementBase
 {
@@ -427,7 +427,7 @@ public:
     bool IsStation() const;
     bool IsBlockStart() const;
 };
-assert_struct_size(TrackElement, 16);
+static_assert(sizeof(TrackElement) == 16);
 
 struct SmallSceneryElement : TileElementBase
 {
@@ -462,7 +462,7 @@ public:
     void SetNeedsSupports();
     void UpdateAge(const CoordsXY& sceneryPos);
 };
-assert_struct_size(SmallSceneryElement, 16);
+static_assert(sizeof(SmallSceneryElement) == 16);
 
 struct LargeSceneryElement : TileElementBase
 {
@@ -502,7 +502,7 @@ public:
     bool IsAccounted() const;
     void SetIsAccounted(bool isAccounted);
 };
-assert_struct_size(LargeSceneryElement, 16);
+static_assert(sizeof(LargeSceneryElement) == 16);
 
 struct WallElement : TileElementBase
 {
@@ -547,7 +547,7 @@ public:
     bool AnimationIsBackwards() const;
     void SetAnimationIsBackwards(bool isBackwards);
 };
-assert_struct_size(WallElement, 16);
+static_assert(sizeof(WallElement) == 16);
 
 struct EntranceElement : TileElementBase
 {
@@ -592,7 +592,7 @@ public:
 
     int32_t GetDirections() const;
 };
-assert_struct_size(EntranceElement, 16);
+static_assert(sizeof(EntranceElement) == 16);
 
 struct BannerElement : TileElementBase
 {
@@ -620,7 +620,7 @@ public:
     void SetAllowedEdges(uint8_t newEdges);
     void ResetAllowedEdges();
 };
-assert_struct_size(BannerElement, 16);
+static_assert(sizeof(BannerElement) == 16);
 
 #pragma pack(pop)